// The type init slot.
static int pyqtSignal_init(PyObject *self, PyObject *args, PyObject *kwd_args)
{
qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)self;
// Get the keyword arguments.
PyObject *name_obj = 0;
const char *name = 0;
int revision = 0;
QList<QByteArray> *parameter_names = 0;
if (kwd_args)
{
Py_ssize_t pos = 0;
PyObject *key, *value;
while (PyDict_Next(kwd_args, &pos, &key, &value))
{
#if PY_MAJOR_VERSION >= 3
if (PyUnicode_CompareWithASCIIString(key, "name") == 0)
#else
Q_ASSERT(PyString_Check(key));
if (qstrcmp(PyString_AsString(key), "name") == 0)
#endif
{
name_obj = value;
name = sipString_AsASCIIString(&name_obj);
if (!name)
{
PyErr_Format(PyExc_TypeError,
"signal 'name' must be a str, not %s",
sipPyTypeName(Py_TYPE(value)));
return -1;
}
}
#if PY_MAJOR_VERSION >= 3
else if (PyUnicode_CompareWithASCIIString(key, "revision") == 0)
#else
else if (qstrcmp(PyString_AsString(key), "revision") == 0)
#endif
{
revision = sipLong_AsInt(value);
if (PyErr_Occurred())
{
if (PyErr_ExceptionMatches(PyExc_TypeError))
PyErr_Format(PyExc_TypeError,
"signal 'revision' must be an int, not %s",
sipPyTypeName(Py_TYPE(value)));
Py_XDECREF(name_obj);
return -1;
}
}
#if PY_MAJOR_VERSION >= 3
else if (PyUnicode_CompareWithASCIIString(key, "arguments") == 0)
#else
else if (qstrcmp(PyString_AsString(key), "arguments") == 0)
#endif
{
bool ok = true;
if (PySequence_Check(value))
{
Py_ssize_t len = PySequence_Size(value);
parameter_names = new QList<QByteArray>;
for (Py_ssize_t i = 0; i < len; ++i)
{
PyObject *py_attr = PySequence_GetItem(value, i);
if (!py_attr)
{
ok = false;
break;
}
PyObject *py_ascii_attr = py_attr;
const char *attr = sipString_AsASCIIString(
&py_ascii_attr);
Py_DECREF(py_attr);
if (!attr)
{
ok = false;
break;
}
parameter_names->append(QByteArray(attr));
Py_DECREF(py_ascii_attr);
}
}
else
{
ok = false;
}
if (!ok)
{
PyErr_Format(PyExc_TypeError,
"signal 'attribute_names' must be a sequence of str, not %s",
sipPyTypeName(Py_TYPE(value)));
if (parameter_names)
delete parameter_names;
Py_XDECREF(name_obj);
return -1;
}
}
else
{
#if PY_MAJOR_VERSION >= 3
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%U'",
key);
#else
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%s'",
PyString_AsString(key));
#endif
Py_XDECREF(name_obj);
return -1;
}
}
}
// If there is at least one argument and it is a sequence then assume all
// arguments are sequences. Unfortunately a string is also a sequence so
// check for tuples and lists explicitly.
if (PyTuple_Size(args) > 0 && (PyTuple_Check(PyTuple_GetItem(args, 0)) || PyList_Check(PyTuple_GetItem(args, 0))))
{
for (Py_ssize_t i = 0; i < PyTuple_Size(args); ++i)
{
PyObject *types = PySequence_Tuple(PyTuple_GetItem(args, i));
if (!types)
{
PyErr_SetString(PyExc_TypeError,
"pyqtSignal() argument expected to be sequence of types");
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
int rc;
if (i == 0)
{
// The first is the default.
rc = init_signal_from_types(ps, name, parameter_names,
revision, types);
}
else
{
qpycore_pyqtSignal *overload = (qpycore_pyqtSignal *)PyType_GenericNew(qpycore_pyqtSignal_TypeObject, 0, 0);
if (!overload)
{
rc = -1;
}
else if ((rc = init_signal_from_types(overload, name, 0, revision, types)) < 0)
{
Py_DECREF((PyObject *)overload);
}
else
{
overload->default_signal = ps;
append_overload(overload);
}
}
Py_DECREF(types);
if (rc < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
}
}
else if (init_signal_from_types(ps, name, parameter_names, revision, args) < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
if (name)
{
Py_DECREF(name_obj);
}
return 0;
}
// The type init slot.
static int pyqtSignal_init(PyObject *self, PyObject *args, PyObject *kwd_args)
{
qpycore_pyqtSignal *ps = (qpycore_pyqtSignal *)self;
// Get the keyword arguments.
PyObject *name_obj = 0;
const char *name = 0;
if (kwd_args)
{
SIP_SSIZE_T pos = 0;
PyObject *key, *value;
while (PyDict_Next(kwd_args, &pos, &key, &value))
{
#if PY_MAJOR_VERSION >= 3
if (PyUnicode_CompareWithASCIIString(key, "name") != 0)
{
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%U'",
key);
Py_XDECREF(name_obj);
return -1;
}
#else
Q_ASSERT(PyString_Check(key));
if (qstrcmp(PyString_AS_STRING(key), "name") != 0)
{
PyErr_Format(PyExc_TypeError,
"pyqtSignal() got an unexpected keyword argument '%s'",
PyString_AS_STRING(key));
Py_XDECREF(name_obj);
return -1;
}
#endif
name_obj = value;
name = sipString_AsASCIIString(&name_obj);
if (!name)
return -1;
}
}
// If there is at least one argument and it is a sequence then assume all
// arguments are sequences. Unfortunately a string is also a sequence so
// check for tuples and lists explicitly.
if (PyTuple_GET_SIZE(args) > 0 && (PyTuple_Check(PyTuple_GET_ITEM(args, 0)) || PyList_Check(PyTuple_GET_ITEM(args, 0))))
{
for (SIP_SSIZE_T i = 0; i < PyTuple_GET_SIZE(args); ++i)
{
PyObject *types = PySequence_Tuple(PyTuple_GET_ITEM(args, i));
if (!types)
{
PyErr_SetString(PyExc_TypeError,
"pyqtSignal() argument expected to be sequence of types");
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
int rc;
if (i == 0)
{
// The first is the default.
rc = init_signal_from_types(ps, name, types);
}
else
{
qpycore_pyqtSignal *overload = (qpycore_pyqtSignal *)PyType_GenericNew(&qpycore_pyqtSignal_Type, 0, 0);
if (!overload)
{
rc = -1;
}
else if ((rc = init_signal_from_types(overload, name, types)) < 0)
{
Py_DECREF((PyObject *)overload);
}
else
{
overload->default_signal = ps;
append_overload(overload);
}
}
Py_DECREF(types);
if (rc < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
}
}
else if (init_signal_from_types(ps, name, args) < 0)
{
if (name)
{
Py_DECREF(name_obj);
}
return -1;
}
if (name)
{
Py_DECREF(name_obj);
}
return 0;
}
