summaryrefslogtreecommitdiffstats
path: root/libshiboken/sbkconverter_p.h
blob: 8abdc297a5faeec9137fdd2c0123f9b95cb215b7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
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
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
/*
 * This file is part of the Shiboken Python Bindings Generator project.
 *
 * Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 *
 * Contact: PySide team <contact@pyside.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef SBK_CONVERTER_P_H
#define SBK_CONVERTER_P_H

#include <Python.h>
#include <list>
#include <limits>
#include "sbkconverter.h"

#include "sbkdbg.h"

extern "C"
{

typedef std::pair<IsConvertibleToCppFunc, PythonToCppFunc> ToCppConversion;
typedef std::list<ToCppConversion> ToCppConversionList;

/**
 *  \internal
 *  Private structure of SbkConverter.
 */
struct SbkConverter
{
    /**
     *  TODO: it certainly will be empty in some cases, like with PyDate.
     *  TODO: probably a setPythonType(SbkConverter*, PyTypeObject*) function will be required.
     *  Python type associated with this converter. If the type is a Shiboken
     *  wrapper, then it must be a SbkObjectType; otherwise it will be the
     *  Python type to which the C++ value will be converted (note that the
     *  C++ type could be produced from various Python types).
     */
    PyTypeObject*           pythonType;
    /**
     *  This function converts a C++ object to a Python object of the type
     *  indicated in pythonType. The identity of the C++ object is kept,
     *  because it looks for an already existing Python wrapper associated
     *  with the C++ instance.
     *  It is used to convert C++ pointers and references to Python objects.
     */
    CppToPythonFunc         pointerToPython;
    /**
     *  This function converts a C++ object to a Python object of the type
     *  indicated in pythonType. The identity of the is not kept, because a
     *  new instance of the C++ object is created.
     *  It is used to convert objects passed by value, or reference, if said
     *  reference can't be traced to an object that already has a Python
     *  wrapper assigned for it.
     */
    CppToPythonFunc         copyToPython;
    /**
     *  This is a special case of a Python to C++ conversion. It returns
     *  the underlying C++ pointer of a Python wrapper passed as parameter
     *  or NULL if the Python object is a None value.
     *  It comes separated from the other toCppConversions because if you
     *  have a Python object representing a Value Type the type checking
     *  for both ValueType and ValueType* would be the same, thus the first
     *  check would be true and the second would never be reached.
     */
    ToCppConversion         toCppPointerConversion;
    /**
     *  This is a list of type checking functions that return the
     *  proper Python to C++ conversion function, for the given Python
     *  object.
     *  For Object Types, that never have implicit conversions, this
     *  list is always empty.
     */
    ToCppConversionList     toCppConversions;
};

} // extern "C"

// Helper template for checking if a value overflows when cast to type T.
template<typename T, bool isSigned = std::numeric_limits<T>::is_signed >
struct OverFlowChecker;

template<typename T>
struct OverFlowChecker<T, true> {
    static bool check(const PY_LONG_LONG& value) {
        return value < std::numeric_limits<T>::min() || value > std::numeric_limits<T>::max();
    }
};
template<typename T>
struct OverFlowChecker<T, false> {
    static bool check(const PY_LONG_LONG& value) {
        return value < 0 || static_cast<unsigned long long>(value) > std::numeric_limits<T>::max();
    }
};
template<>
struct OverFlowChecker<PY_LONG_LONG, true> {
    static bool check(const PY_LONG_LONG& value) { return false; }
};
template<>
struct OverFlowChecker<double, true> {
    static bool check(const double& value) { return false; }
};
template<>
struct OverFlowChecker<float, true> {
    static bool check(const double& value) {
        return value < std::numeric_limits<float>::min() || value > std::numeric_limits<float>::max();
    }
};

// Basic primitive type converters ---------------------------------------------------------
template<typename T> PyTypeObject* SbkType() { return 0; }
template<> inline PyTypeObject* SbkType<PY_LONG_LONG>() { return &PyLong_Type; }
template<> inline PyTypeObject* SbkType<bool>() { return &PyBool_Type; }
template<> inline PyTypeObject* SbkType<char>() { return &PyInt_Type; }
template<> inline PyTypeObject* SbkType<const char*>() { return &PyString_Type; }
template<> inline PyTypeObject* SbkType<double>() { return &PyFloat_Type; }
template<> inline PyTypeObject* SbkType<float>() { return &PyFloat_Type; }
template<> inline PyTypeObject* SbkType<int>() { return &PyInt_Type; }
template<> inline PyTypeObject* SbkType<long>() { return &PyLong_Type; }
template<> inline PyTypeObject* SbkType<short>() { return &PyInt_Type; }
template<> inline PyTypeObject* SbkType<signed char>() { return &PyInt_Type; }
template<> inline PyTypeObject* SbkType<unsigned PY_LONG_LONG>() { return &PyLong_Type; }
template<> inline PyTypeObject* SbkType<unsigned char>() { return &PyInt_Type; }
template<> inline PyTypeObject* SbkType<unsigned int>() { return &PyLong_Type; }
template<> inline PyTypeObject* SbkType<unsigned long>() { return &PyLong_Type; }
template<> inline PyTypeObject* SbkType<unsigned short>() { return &PyInt_Type; }

template <typename T> struct Primitive {};

template <typename T>
struct OnePrimitive
{
    static PyObject* toPython(const void*) { return 0; }
    static PythonToCppFunc isConvertible(PyObject*) { return 0; }
    static void toCpp(PyObject*, void*) {}
    static SbkConverter* createConverter()
    {
        SbkConverter* converter = Shiboken::Conversions::createConverter(SbkType<T>(), Primitive<T>::toPython);
        Shiboken::Conversions::addPythonToCppValueConversion(converter, Primitive<T>::toCpp, Primitive<T>::isConvertible);
        return converter;
    }
};
template <typename T>
struct TwoPrimitive : OnePrimitive<T>
{
    static PythonToCppFunc isOtherConvertible(PyObject*) { return 0; }
    static void otherToCpp(PyObject*, void*) {}
    static SbkConverter* createConverter()
    {
        SbkConverter* converter = OnePrimitive<T>::createConverter();
        Shiboken::Conversions::addPythonToCppValueConversion(converter, Primitive<T>::otherToCpp, Primitive<T>::isOtherConvertible);
        return converter;
    }
};

// Integers --------------------------------------------------------------------------------

// Note: if there wasn't for the old-style classes, a simple PyNumber_Check would suffice.
#define SbkNumber_Check(X) (PyNumber_Check(X) \
        && (!PyInstance_Check(X) || PyObject_HasAttrString(X, "__trunc__")))

template <typename INT>
struct IntPrimitive : TwoPrimitive<INT>
{
    static PyObject* toPython(const void* cppIn)
    {
        return PyInt_FromLong((long)*((INT*)cppIn));
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        double result = PyFloat_AS_DOUBLE(pyIn);
        // If cast to long directly it could overflow silently.
        if (OverFlowChecker<INT>::check(result))
            PyErr_SetObject(PyExc_OverflowError, 0);
        *((INT*)cppOut) = static_cast<INT>(result);
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (PyFloat_Check(pyIn))
            return toCpp;
        return 0;
    }
    static void otherToCpp(PyObject* pyIn, void* cppOut)
    {
        PY_LONG_LONG result = PyLong_AsLongLong(pyIn);
        if (OverFlowChecker<INT>::check(result))
            PyErr_SetObject(PyExc_OverflowError, 0);
        *((INT*)cppOut) = static_cast<INT>(result);
    }
    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
    {
        if (SbkNumber_Check(pyIn))
            return otherToCpp;
        return 0;
    }
};
template <> struct Primitive<int> : IntPrimitive<int> {};
template <> struct Primitive<long> : IntPrimitive<long> {};
template <> struct Primitive<short> : IntPrimitive<short> {};
template <> struct Primitive<unsigned short> : IntPrimitive<unsigned short> {};

// Unsigned Long Integers ------------------------------------------------------------------

template <typename LONG>
struct UnsignedLongPrimitive : IntPrimitive<LONG>
{
    static PyObject* toPython(const void* cppIn)
    {
        return PyLong_FromUnsignedLong(*((LONG*)cppIn));
    }
};
template <> struct Primitive<unsigned int> : UnsignedLongPrimitive<unsigned int> {};
template <> struct Primitive<unsigned long> : UnsignedLongPrimitive<unsigned long> {};

// Big integers ----------------------------------------------------------------------------

template <>
struct Primitive<PY_LONG_LONG> : OnePrimitive<PY_LONG_LONG>
{
    static PyObject* toPython(const void* cppIn)
    {
        return PyLong_FromLongLong(*((PY_LONG_LONG*)cppIn));
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        *((PY_LONG_LONG*)cppOut) = (PY_LONG_LONG) PyLong_AsLongLong(pyIn);
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (SbkNumber_Check(pyIn))
            return toCpp;
        return 0;
    }
};

template <>
struct Primitive<unsigned PY_LONG_LONG> : OnePrimitive<unsigned PY_LONG_LONG>
{
    static PyObject* toPython(const void* cppIn)
    {
        return PyLong_FromUnsignedLongLong(*((unsigned PY_LONG_LONG*)cppIn));
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        *((unsigned PY_LONG_LONG*)cppOut) = (unsigned PY_LONG_LONG) PyLong_AsUnsignedLongLong(pyIn);
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (SbkNumber_Check(pyIn))
            return toCpp;
        return 0;
    }
};

// Floating point --------------------------------------------------------------------------

template <typename FLOAT>
struct FloatPrimitive : TwoPrimitive<FLOAT>
{
    static PyObject* toPython(const void* cppIn)
    {
        return PyFloat_FromDouble((double)*((FLOAT*)cppIn));
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        *((FLOAT*)cppOut) = (FLOAT) PyLong_AsLong(pyIn);
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (PyInt_Check(pyIn) || PyLong_Check(pyIn))
            return toCpp;
        return 0;
    }
    static void otherToCpp(PyObject* pyIn, void* cppOut)
    {
        *((FLOAT*)cppOut) = (FLOAT) PyFloat_AsDouble(pyIn);
    }
    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
    {
        if (SbkNumber_Check(pyIn))
            return otherToCpp;
        return 0;
    }
};
template <> struct Primitive<float> : FloatPrimitive<float> {};
template <> struct Primitive<double> : FloatPrimitive<double> {};

// Boolean ---------------------------------------------------------------------------------

template <>
struct Primitive<bool> : OnePrimitive<bool>
{
    static PyObject* toPython(const void* cppIn)
    {
        return PyBool_FromLong(*((bool*)cppIn));
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (SbkNumber_Check(pyIn))
            return toCpp;
        return 0;
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        *((bool*)cppOut) = (bool) PyInt_AS_LONG(pyIn);
    }
};

// Characters ------------------------------------------------------------------------------

template <typename CHAR>
struct CharPrimitive : IntPrimitive<CHAR>
{
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        *((CHAR*)cppOut) = (CHAR) PyString_AS_STRING(pyIn)[0];
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (PyString_Check(pyIn) && PyString_Size(pyIn) == 1)
            return toCpp;
        return 0;
    }
    static void otherToCpp(PyObject* pyIn, void* cppOut)
    {
        PY_LONG_LONG result = PyLong_AsLongLong(pyIn);
        if (OverFlowChecker<CHAR>::check(result))
            PyErr_SetObject(PyExc_OverflowError, 0);
        *((CHAR*)cppOut) = (CHAR) result;
    }
    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
    {
        if (SbkNumber_Check(pyIn))
            return otherToCpp;
        return 0;
    }
    static SbkConverter* createConverter()
    {
        SbkConverter* converter = IntPrimitive<CHAR>::createConverter();
        Shiboken::Conversions::addPythonToCppValueConversion(converter, CharPrimitive<CHAR>::otherToCpp, CharPrimitive<CHAR>::isOtherConvertible);
        return converter;
    }

};
template <> struct Primitive<signed char> : CharPrimitive<signed char> {};
template <> struct Primitive<unsigned char> : CharPrimitive<unsigned char> {};
template <> struct Primitive<char> : CharPrimitive<char> {
    using CharPrimitive<char>::toPython;
    static PyObject* toPython(const void* cppIn) {
        return PyString_FromFormat("%c", *((const char*)cppIn));
    }
};



// Strings ---------------------------------------------------------------------------------

template <>
struct Primitive<const char*> : TwoPrimitive<const char*>
{
    static PyObject* toPython(const void* cppIn)
    {
        if (!cppIn)
            Py_RETURN_NONE;
        return PyString_FromString((const char*)cppIn);
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        *((const char**)cppOut) = 0;
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (pyIn == Py_None)
            return toCpp;
        return 0;
    }
    static void otherToCpp(PyObject* pyIn, void* cppOut)
    {
        *((const char**)cppOut) = (const char*) PyString_AsString(pyIn);
    }
    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
    {
        if (PyString_Check(pyIn))
            return otherToCpp;
        return 0;
    }
};

template <>
struct Primitive<std::string> : TwoPrimitive<std::string>
{
    static PyObject* toPython(const void* cppIn)
    {
        return PyString_FromString(((std::string*)cppIn)->c_str());
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        *((std::string*)cppOut) = std::string();
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        if (pyIn == Py_None)
            return toCpp;
        return 0;
    }
    static void otherToCpp(PyObject* pyIn, void* cppOut)
    {
        *((std::string*)cppOut) = std::string(PyString_AsString(pyIn));
    }
    static PythonToCppFunc isOtherConvertible(PyObject* pyIn)
    {
        if (PyString_Check(pyIn))
            return otherToCpp;
        return 0;
    }
};

// Void pointer ----------------------------------------------------------------------------

template <>
struct Primitive<void*> : OnePrimitive<void*>
{
    static PyObject* toPython(const void* cppIn)
    {
        SbkDbg() << cppIn;
        if (!cppIn)
            Py_RETURN_NONE;
        PyObject* result = (PyObject*) cppIn;
        Py_INCREF(result);
        return result;
    }
    static void toCpp(PyObject* pyIn, void* cppOut)
    {
        SbkDbg() << pyIn;
        *((void**)cppOut) = pyIn;
    }
    static PythonToCppFunc isConvertible(PyObject* pyIn)
    {
        return toCpp;
    }
};

#endif // SBK_CONVERTER_P_H