return PyLong_FromSize_t(%in);

%out = %OUTTYPE(PyLong_AsSsize_t(%in));

static bool Check2TupleOfNumbers(PyObject* pyIn) { if (!PySequence_Check(pyIn) || !(PySequence_Size(pyIn) == 2)) return false; Shiboken::AutoDecRef pyReal(PySequence_GetItem(pyIn, 0)); if (!SbkNumber_Check(pyReal)) return false; Shiboken::AutoDecRef pyImag(PySequence_GetItem(pyIn, 1)); if (!SbkNumber_Check(pyImag)) return false; return true; }

return PyComplex_FromDoubles(%in.real(), %in.imag());

double real = PyComplex_RealAsDouble(%in); double imag = PyComplex_ImagAsDouble(%in); %out = %OUTTYPE(real, imag);

Shiboken::AutoDecRef pyReal(PySequence_GetItem(%in, 0)); Shiboken::AutoDecRef pyImag(PySequence_GetItem(%in, 1)); double real = %CONVERTTOCPP[double](pyReal); double imag = %CONVERTTOCPP[double](pyImag); %out = %OUTTYPE(real, imag);

SBK_UNUSED(%in); Py_RETURN_NONE;

%out = %OUTTYPE(%in == 0);

if (!%in) Py_RETURN_NONE; #ifdef IS_PY3K return PyCapsule_New(%in, 0, 0); #else return PyCObject_FromVoidPtr(%in, 0); #endif

%out = 0;

void* ptr; #ifdef IS_PY3K ptr = PyCapsule_GetPointer(%in, 0); #else ptr = PyCObject_AsVoidPtr(%in); #endif %out = (%OUTTYPE)ptr;

static bool checkPyCapsuleOrPyCObject(PyObject* pyObj) { #ifdef IS_PY3K return PyCapsule_CheckExact(pyObj); #else return PyCObject_Check(pyObj); #endif }

#ifdef IS_PY3K return PyCapsule_New(&%in, 0, 0); #else return PyCObject_FromVoidPtr(&%in, 0); #endif

void* ptr; #ifdef IS_PY3K ptr = PyCapsule_GetPointer(%in, 0); #else ptr = PyCObject_AsVoidPtr(%in); #endif %out = *((%OUTTYPE*)ptr);

return PyBool_FromLong(%in.value());

// Tests CONVERTTOCPP macro with C++ primitive type. bool b = %CONVERTTOCPP[bool](%in); %out = %OUTTYPE(b);

// Tests CONVERTTOCPP macro with user's primitive type. Complex cpx = %CONVERTTOCPP[Complex](%in); %out = %OUTTYPE(cpx.real() != 0.0 || cpx.imag() != 0.0);

return Shiboken::String::fromCString(%in.cstring(), %in.size());

const char* str = %CONVERTTOCPP[const char*](%in); %out = %OUTTYPE(str);

%out = %OUTTYPE();

%FUNCTION_NAME(&%1, %2); %PYARG_0 = %CONVERTTOPYTHON[PStr](%1);

%FUNCTION_NAME(&%1); %PYARG_0 = %CONVERTTOPYTHON[PStr](%1);

PyObject* %out = PyList_New((int) %in.size()); PStrList::const_iterator it = %in.begin(); for (int idx = 0; it != %in.end(); ++it, ++idx) { PStr cppItem(*it); PyList_SET_ITEM(%out, idx, %CONVERTTOPYTHON[PStr](cppItem)); } return %out;

%OUTTYPE& list = %out; Shiboken::AutoDecRef seq(PySequence_Fast(%in, 0)); for (int i = 0; i < PySequence_Fast_GET_SIZE(seq.object()); i++) { PyObject* pyItem = PySequence_Fast_GET_ITEM(seq.object(), i); PStr cppItem = %CONVERTTOCPP[PStr](pyItem); list.push_back(cppItem); }

PStrList %0; %0.push_back(%1); %0.push_back(%2); %PYARG_0 = %CONVERTTOPYTHON[PStrList](%0);

std::list<PStr> %0; %0.push_back(%1); %0.push_back(%2); %PYARG_0 = %CONVERTTOPYTHON[std::list<PStr>](%0);

%PYARG_0 = (PyObject*) Shiboken::Conversions::getPythonTypeObject(%1); if (!%PYARG_0) %PYARG_0 = Py_None; Py_INCREF(%PYARG_0);

Shiboken::Conversions::SpecificConverter converter(%1); const char* %0 = 0; switch (converter.conversionType()) { case Shiboken::Conversions::SpecificConverter::CopyConversion: %0 = "Copy conversion"; break; case Shiboken::Conversions::SpecificConverter::PointerConversion: %0 = "Pointer conversion"; break; case Shiboken::Conversions::SpecificConverter::ReferenceConversion: %0 = "Reference conversion"; break; default: %0 = "Invalid conversion"; } %PYARG_0 = %CONVERTTOPYTHON[const char*](%0);

static PyObject* __convertCppValuesToPython(const char** typeName, void** values, int size) { PyObject* result = PyTuple_New(size); for (int i = 0; i < size; ++i) { Shiboken::Conversions::SpecificConverter converter(typeName[i]); PyTuple_SET_ITEM(result, i, converter.toPython(values[i])); } return result; }

const char* typeNames[] = { "Point", "Point*", "Point&" }; void* values[] = { &%1, &%2, &(%3) }; %PYARG_0 = __convertCppValuesToPython(typeNames, values, 3);

const char* typeNames[] = { "ObjectType*", "ObjectType&" }; void* values[] = { &%1, &(%2) }; %PYARG_0 = __convertCppValuesToPython(typeNames, values, 2);

const char* typeNames[] = { "std::list<int>" }; void* values[] = { &%1 }; %PYARG_0 = __convertCppValuesToPython(typeNames, values, 1);

const char* typeNames[] = { "int", "int" }; void* values[] = { &%1, &%2 }; %PYARG_0 = __convertCppValuesToPython(typeNames, values, 2);

PyObject* %out = PyTuple_New(2); PyTuple_SET_ITEM(%out, 0, %CONVERTTOPYTHON[%INTYPE_0](%in.first)); PyTuple_SET_ITEM(%out, 1, %CONVERTTOPYTHON[%INTYPE_1](%in.second)); return %out;

%out.first = %CONVERTTOCPP[%OUTTYPE_0](PySequence_Fast_GET_ITEM(%in, 0)); %out.second = %CONVERTTOCPP[%OUTTYPE_1](PySequence_Fast_GET_ITEM(%in, 1));

PyObject* %out = PyDict_New(); %INTYPE::const_iterator it = %in.begin(); for (; it != %in.end(); ++it) { %INTYPE_0 key = it->first; %INTYPE_1 value = it->second; PyDict_SetItem(%out, %CONVERTTOPYTHON[%INTYPE_0](key), %CONVERTTOPYTHON[%INTYPE_1](value)); } return %out;

PyObject* key; PyObject* value; Py_ssize_t pos = 0; while (PyDict_Next(%in, &pos, &key, &value)) { %OUTTYPE_0 cppKey = %CONVERTTOCPP[%OUTTYPE_0](key); %OUTTYPE_1 cppValue = %CONVERTTOCPP[%OUTTYPE_1](value); %out.insert(%OUTTYPE::value_type(cppKey, cppValue)); }

%RETURN_TYPE %0 = Shiboken::BindingManager::instance().getAllPyObjects().size(); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

const unsigned char* %out = reinterpret_cast<const unsigned char*>(Shiboken::String::toCString(%PYARG_1));

unsigned int %out = static_cast<unsigned int>(Shiboken::String::len(%PYARG_1));

%RETURN_TYPE %0 = %1 + %2; %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

%RETURN_TYPE %0 = %1.x() + %1.y(); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

// The dot in "%1." must be replaced with a "->" by the generator. %RETURN_TYPE %0 = %1.objectName().size(); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

const char* tmpArg = %CONVERTTOCPP[const char*](%PYARG_1); %0 = new %FUNCTION_NAME(atoi(tmpArg));

static void reparent_layout_items(PyObject* parent, PyObject* layout) { // CHECKTYPE and ISCONVERTIBLE are used here for test purposes, don't change them. if (!%CHECKTYPE[ObjectTypeLayout*](layout) && !%ISCONVERTIBLE[ObjectTypeLayout*](layout)) return; // %CHECKTYPE[ObjectTypeLayout*](layout) // %ISCONVERTIBLE[ObjectTypeLayout*](layout) ObjectTypeLayout* var; var = %CONVERTTOCPP[ObjectTypeLayout*](layout); // TODO-CONVERTER: erase this /* ObjectTypeLayout* var2 = %CONVERTTOCPP[ObjectTypeLayout*](layout); */ const ObjectTypeList& objChildren = var->objects(); ObjectTypeList::const_iterator it = objChildren.begin(); for (; it != objChildren.end(); ++it) { if ((*it)->isLayoutType()) { ObjectTypeLayout* l = reinterpret_cast<ObjectTypeLayout*>(*it); reparent_layout_items(parent, %CONVERTTOPYTHON[ObjectTypeLayout*](l)); Shiboken::Object::setParent(layout, %CONVERTTOPYTHON[ObjectTypeLayout*](l)); } else { Shiboken::Object::setParent(parent, %CONVERTTOPYTHON[ObjectType*](*it)); } } }

if (%PYARG_1 != Py_None) reparent_layout_items(%PYSELF, %PYARG_1);

%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, %2) * 10; %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%PYARG_1); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, true, %3, %4); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

int %out = PySequence_Size(%PYARG_1);

Shiboken::AutoArrayPointer<Point> %out(%1); for (int i = 0; i < %1; ++i) %out[i] = %CONVERTTOCPP[Point](PySequence_Fast_GET_ITEM(%PYARG_1, i));

int size = (%2 < 0) ? %1.size() : %2; %BEGIN_ALLOW_THREADS %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME((const void*) %1.data(), size); %END_ALLOW_THREADS %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

Shiboken::AutoDecRef _py_ok_(PySequence_GetItem(%PYARG_0, 0)); Shiboken::AutoDecRef _py_ret_(PySequence_GetItem(%PYARG_0, 1)); *%2 = %CONVERTTOCPP[bool](_py_ok_); %RETURN_TYPE %out = %CONVERTTOCPP[%RETURN_TYPE](_py_ret_);

ObjectType* tmpObject = 0; %BEGIN_ALLOW_THREADS %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(&tmpObject); %END_ALLOW_THREADS %PYARG_0 = PyTuple_New(2); PyTuple_SET_ITEM(%PYARG_0, 0, %CONVERTTOPYTHON[%RETURN_TYPE](%0)); PyTuple_SET_ITEM(%PYARG_0, 1, %CONVERTTOPYTHON[ObjectType*](tmpObject));

%RETURN_TYPE %0 = !%CPPSELF.%FUNCTION_NAME(%1); %PYARG_0 = %CONVERTTOPYTHON[OddBool](%0);

%RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, %1+%3, %3); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

PyObject* new_arg0 = PyInt_FromLong(PyInt_AS_LONG(%PYARG_1) - %2); Py_DECREF(%PYARG_1); %PYARG_1 = new_arg0;

%0.prepend(Str("Pimped"));

PyObject_Call(%PYTHON_METHOD_OVERRIDE, %PYTHON_ARGUMENTS, NULL);

Shiboken::AutoDecRef _py_ok_(PySequence_GetItem(%PYARG_0, 0)); Shiboken::AutoDecRef _py_ret_(PySequence_GetItem(%PYARG_0, 1)); %RETURN_TYPE %out = %CONVERTTOCPP[%RETURN_TYPE](_py_ok_); %2 = %CONVERTTOCPP[Str*](_py_ret_);

Str* _str_arg_ = 0; %RETURN_TYPE %0 = %CPPSELF.%TYPE::%FUNCTION_NAME(%1, _str_arg_);

%PYARG_0 = PyTuple_New(2); PyObject* _item_ = %CONVERTTOPYTHON[%RETURN_TYPE](%0); PyTuple_SET_ITEM(%PYARG_0, 0, _item_); _item_ = %CONVERTTOPYTHON[Str*](_str_arg_); PyTuple_SET_ITEM(%PYARG_0, 1, _item_);

Str* _str_arg_ = 0; %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, _str_arg_);

%BEGIN_ALLOW_THREADS // It's important for test purposes to use a constructor with parenthesis as argument. %RETURN_TYPE %0 = %RETURN_TYPE(%CPPSELF.%FUNCTION_NAME(Str(%1))); %END_ALLOW_THREADS %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

%0 = new %TYPE(%PYARG_1);

%PYARG_0 = reinterpret_cast<PyObject*>(%CPPSELF.%FUNCTION_NAME()); if (!%PYARG_0) %PYARG_0 = Py_None; Py_INCREF(%PYARG_0);

bool ok_; %RETURN_TYPE retval_ = %FUNCTION_NAME(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, &ok_); if (!ok_) %PYARG_0 = Py_None; else %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](retval_);

typedef std::list<int> Inner; typedef std::list<Inner> Outer; int result = 0; Outer::const_iterator oiter, oend = %1.end(); for (oiter = %1.begin(); oiter != oend; ++oiter) { const Inner& inner = *oiter; Inner::const_iterator iiter, iend = inner.end(); for (iiter = inner.begin(); iiter != iend; ++iiter) result += *iiter; } %PYARG_0 = %CONVERTTOPYTHON[int](result);

typedef std::pair<int, int> Pair; typedef std::list<Pair> List; int result = 0; List::const_iterator iter, end = %1.end(); for (iter = %1.begin(); iter != end; ++iter) result += iter->first * iter->second; %PYARG_0 = %CONVERTTOPYTHON[int](result);

int* array = NULL; bool errorOccurred = false; if (PySequence_Check(%PYARG_1)) { if((array = Shiboken::sequenceToIntArray(%PYARG_1, true)) == NULL && PyErr_Occurred()) { PyErr_SetString(PyExc_TypeError, "Should be a sequence of ints"); errorOccurred = true; } } else { PyErr_SetString(PyExc_TypeError, "Should be a sequence of ints"); errorOccurred = true; } if (!errorOccurred) { %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(array); if (array) delete[] array; %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); }

int %out = PySequence_Size(%PYARG_1);

int numItems = PySequence_Size(%PYARG_1); Shiboken::AutoArrayPointer<int> %out(numItems); for (int i = 0; i < numItems; ++i) { if (%CHECKTYPE[int](PySequence_Fast_GET_ITEM(%PYARG_1, i))) %out[i] = %CONVERTTOCPP[int](PySequence_Fast_GET_ITEM(%PYARG_1, i)); else if (%ISCONVERTIBLE[int](PySequence_Fast_GET_ITEM(%PYARG_1, i))) %out[i] = -1; else %out[i] = -2; }

PyObject* %out = PyList_New(count); for (int i = 0; i < count; ++i) PyList_SET_ITEM(%out, i, %CONVERTTOPYTHON[int](%in[i]));

int numItems = PySequence_Size(%PYARG_1); int *cppItems = new int[numItems]; for (int i = 0; i < numItems; i++) cppItems[i] = %CONVERTTOCPP[int](PySequence_GetItem(%PYARG_1, i)); %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(numItems, cppItems); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); delete[] cppItems;

PyObject* InjectCode_tpstr(PyObject*) { return Shiboken::String::fromCString("Hi! I'm the inject code dummy class."); }

%PYTHONTYPEOBJECT.tp_str = InjectCode_tpstr;

%1 += 1;

PyObject* tmp = Shiboken::String::fromCString("end"); Shiboken::String::concat(&%PYARG_0, tmp); Py_DECREF(tmp);

int argc; char** argv; if (!Shiboken::listToArgcArgv(%PYARG_1, &argc, &argv)) { PyErr_SetString(PyExc_TypeError, "error"); return 0; } %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(argc, argv); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0); for (int i = 0; i < argc; ++i) free(argv[i]); delete[] argv;

return Shiboken::String::fromCString("PyObject");

unsigned char* %out = 0;

int x1 = (int) %CPPSELF.x(); int x2 = ((int) (%CPPSELF.x() * 100)) - (x1 * 100); int y1 = (int) %CPPSELF.y(); int y2 = ((int) (%CPPSELF.y() * 100)) - (y1 * 100); %PYARG_0 = Shiboken::String::fromFormat("Point(%d.%d, %d.%d)", x1, x2, y1, y2);

int x1 = (int) %CPPSELF.x(); int x2 = ((int) (%CPPSELF.x() * 10)) - (x1 * 10); int y1 = (int) %CPPSELF.y(); int y2 = ((int) (%CPPSELF.y() * 10)) - (y1 * 10); %PYARG_0 = Shiboken::String::fromFormat("<Point object at %p: (%d.%d, %d.%d)>", %CPPSELF, x1, x2, y1, y2);

PyObject* type = PyObject_Type(%PYSELF); PyObject* args = NULL; args = Py_BuildValue("(dd)", %CPPSELF.x(), %CPPSELF.y()); %PYARG_0 = Py_BuildValue("(OO)", type, args);

Point _midpoint; // The test consists in *NOT* using the ARGUMENT_NAMES type system variable. %CPPSELF.%FUNCTION_NAME(%1, &_midpoint); %PYARG_0 = %CONVERTTOPYTHON[Point](_midpoint);

int x1 = (int) %CPPSELF.x(); int x2 = ((int) (%CPPSELF.x() * 10)) - (x1 * 10); int y1 = (int) %CPPSELF.y(); int y2 = ((int) (%CPPSELF.y() * 10)) - (y1 * 10); %PYARG_0 = Shiboken::String::fromFormat("<PointF object at %p: (%d.%d, %d.%d)>", %CPPSELF, x1, x2, y1, y2);

PyObject *type = PyObject_Type(%PYSELF); PyObject *args = NULL; args = Py_BuildValue("(dd)", %CPPSELF.x(), %CPPSELF.y()); %PYARG_0 = Py_BuildValue("(OO)", type, args);

PointF _midpoint; // The test consists in using the ARGUMENT_NAMES type system variable. %CPPSELF.%FUNCTION_NAME(%ARGUMENT_NAMES, &_midpoint); %PYARG_0 = %CONVERTTOPYTHON[PointF](_midpoint);

if (!PyDateTimeAPI) PyDateTime_IMPORT; if (PyTime_Check(%1)) { int pyH = PyDateTime_TIME_GET_HOUR(%1); int pyM = PyDateTime_TIME_GET_MINUTE(%1); int pyS = PyDateTime_TIME_GET_SECOND(%1); if ((pyH == %CPPSELF.hour()) && (pyM == %CPPSELF.minute()) && (pyS == %CPPSELF.second())) %PYARG_0 = Py_False; else %PYARG_0 = Py_True; }

%0 = new %TYPE();

Shiboken::AutoDecRef result(PyObject_CallMethod(%PYSELF, const_cast<char*>("setHeight"), const_cast<char*>("i"), 2));

%RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(%1, 2, %3); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

{ Shiboken::AutoDecRef strList(PySequence_Fast(%PYARG_1, "The argument must be a sequence.")); int lineCount = PySequence_Fast_GET_SIZE(strList.object()); for (int line = 0; line < lineCount; ++line) { if (!Shiboken::String::check(PySequence_Fast_GET_ITEM(strList.object(), line))) { PyErr_SetString(PyExc_TypeError, "The argument must be a sequence of strings."); break; } } } const char** %out = 0;

void* %out = 0;

%BEGIN_ALLOW_THREADS %RETURN_TYPE %0 = %CPPSELF.%FUNCTION_NAME(argOut, %2); %END_ALLOW_THREADS %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

%PYARG_0 = Shiboken::String::fromCString(%CPPSELF.cstring());

return %CPPSELF.size();

if (_i < 0 || _i >= %CPPSELF.size()) { PyErr_BadArgument(); return 0; } else { char res[2]; res[0] = %CPPSELF.get_char(_i); res[1] = 0; return Shiboken::String::fromCString(res); }

PyObject* args = Py_BuildValue("(iO)", _i, _value); PyObject* result = Sbk_StrFunc_set_char(self, args); Py_DECREF(args); int ok = result == Py_True; if (result) { Py_DECREF(result); } return !ok ? -1 : 0;

%out = %OUTTYPE();

Py_ssize_t len; const char* str = Shiboken::String::toCString(%in, &len); %out = %OUTTYPE(str, len);

PyObject* data = 0; if (PyUnicode_CheckExact(%PYARG_1)) { data = PyUnicode_AsASCIIString(%PYARG_1); } else { data = %PYARG_1; Py_INCREF(data); } %0 = new %TYPE(PyBytes_AsString(data), PyBytes_GET_SIZE(data)); Py_DECREF(data);

#if PY_VERSION_HEX < 0x03000000 Shiboken::SbkType<ByteArray>()->tp_as_buffer = &SbkByteArrayBufferProc; Shiboken::SbkType<ByteArray>()->tp_flags |= Py_TPFLAGS_HAVE_GETCHARBUFFER; #endif

%PYARG_0 = PyBytes_FromStringAndSize(%CPPSELF.%FUNCTION_NAME(), %CPPSELF.size());

Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); if (!data.isNull()) { ByteArray ba(*%CPPSELF); ba.append(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); %PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba); }

Shiboken::AutoDecRef data(PyUnicode_AsASCIIString(%PYARG_1)); if (!data.isNull()) { ByteArray ba(PyBytes_AsString(data.object()), PyBytes_GET_SIZE(data.object())); ba.append(*%CPPSELF); %PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba); }

ByteArray ba(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)); ba = ba + *%CPPSELF; %PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);

ByteArray ba(PyBytes_AsString(%PYARG_1), PyBytes_GET_SIZE(%PYARG_1)); ba.append(*%CPPSELF); %PYARG_0 = %CONVERTTOPYTHON[ByteArray](ba);

ByteArray b(Py_TYPE(%PYSELF)->tp_name); PyObject* aux = Shiboken::String::fromStringAndSize(%CPPSELF.data(), %CPPSELF.size()); if (PyUnicode_CheckExact(aux)) { PyObject* tmp = PyUnicode_AsASCIIString(aux); Py_DECREF(aux); aux = tmp; } b += "('"; b += ByteArray(PyBytes_AS_STRING(aux), PyBytes_GET_SIZE(aux)); b += "')"; %PYARG_0 = Shiboken::String::fromStringAndSize(b.data(), b.size());

%PYARG_0 = Shiboken::String::fromStringAndSize(%CPPSELF.data(), %CPPSELF.size());

return %CPPSELF.size();

if (_i < 0 || _i >= %CPPSELF.size()) { PyErr_SetString(PyExc_IndexError, "index out of bounds"); return 0; } else { char res[2]; res[0] = %CPPSELF.at(_i); res[1] = 0; return PyBytes_FromStringAndSize(res, 1); }

return %CPPSELF.size();

if (_i < 0 || _i >= static_cast<Py_ssize_t>(%CPPSELF.size())) { PyErr_BadArgument(); return 0; } else { %TYPE::const_iterator it = %CPPSELF.begin(); for (Py_ssize_t i = 1; i <= _i; i++) ++it; return %CONVERTTOPYTHON[Str](*it); }

%PYARG_0 = Shiboken::String::fromCString(%1);

// This should test if code injections works inside rich comparison operators Py_INCREF(Py_True); %PYARG_0 = Py_True;

// Does nothing really, just test the code generation // of constructors whose arguments where long %out = PyInt_AS_LONG(%PYARG_1) + 1;

%PYARG_0 = Shiboken::String::fromCString(""); for (unsigned int i = 0; i < %2; ++i) Shiboken::String::concat(&%PYARG_0, %PYARG_1);

%RETURN_TYPE %0 = PyTuple_GET_SIZE(%PYARG_2); %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

static bool PyDate_ImportAndCheck(PyObject* pyIn) { if (!PyDateTimeAPI) PyDateTime_IMPORT; return PyDate_Check(pyIn); }

int day = PyDateTime_GET_DAY(%in); int month = PyDateTime_GET_MONTH(%in); int year = PyDateTime_GET_YEAR(%in); %out = %OUTTYPE(day, month, year);

if (!PyDateTimeAPI) PyDateTime_IMPORT; %PYARG_0 = PyDate_FromDate(%CPPSELF.day(), %CPPSELF.month(), %CPPSELF.year());

%RETURN_TYPE %0 = %CPPSELF.key() != %1; %PYARG_0 = %CONVERTTOPYTHON[%RETURN_TYPE](%0);

%RETURN_TYPE %0 = *%CPPSELF & %1; return %CONVERTTOPYTHON[%RETURN_TYPE](%0);