_dbus_bindings/containers.c

   1 /* D-Bus container types: Array, Dict and Struct.
   2  *
   3  * Copyright (C) 2006-2007 Collabora Ltd. <http://www.collabora.co.uk/>
   4  *
   5  * Permission is hereby granted, free of charge, to any person
   6  * obtaining a copy of this software and associated documentation
   7  * files (the "Software"), to deal in the Software without
   8  * restriction, including without limitation the rights to use, copy,
   9  * modify, merge, publish, distribute, sublicense, and/or sell copies
  10  * of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be
  14  * included in all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  17  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  19  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  20  * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  21  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  23  * DEALINGS IN THE SOFTWARE.
  24  */
  25
  26 #include <Python.h>
  27 #include <structmember.h>
  28
  29 #include <stdint.h>
  30
  31 #include "dbus_bindings-internal.h"
  32 #include "types-internal.h"
  33
  34 /* Array ============================================================ */
  35
  36 PyDoc_STRVAR(Array_tp_doc,
  37 "An array of similar items, implemented as a subtype of list.\n"
  38 "\n"
  39 "As currently implemented, an Array behaves just like a list, but\n"
  40 "with the addition of a ``signature`` property set by the constructor;\n"
  41 "conversion of its items to D-Bus types is only done when it's sent in\n"
  42 "a Message. This might change in future so validation is done earlier.\n"
  43 "\n"
  44 "Constructor::\n"
  45 "\n"
  46 "    dbus.Array([iterable][, signature][, variant_level])\n"
  47 "\n"
  48 "``variant_level`` must be non-negative; the default is 0.\n"
  49 "\n"
  50 "``signature`` is the D-Bus signature string for a single element of the\n"
  51 "array, or None. If not None it must represent a single complete type, the\n"
  52 "type of a single array item; the signature of the whole Array may be\n"
  53 "obtained by prepending ``a`` to the given signature.\n"
  54 "\n"
  55 "If None (the default), when the Array is sent over\n"
  56 "D-Bus, the item signature will be guessed from the first element.\n"
  57 "\n"
  58 ":IVariables:\n"
  59 "  `variant_level` : int\n"
  60 "    Indicates how many nested Variant containers this object\n"
  61 "    is contained in: if a message's wire format has a variant containing a\n"
  62 "    variant containing an array, this is represented in Python by an\n"
  63 "    Array with variant_level==2.\n"
  64 );
  65
  66 static struct PyMemberDef Array_tp_members[] = {
  67     {"signature", T_OBJECT, offsetof(DBusPyArray, signature), READONLY,
  68      "The D-Bus signature of each element of this Array (a Signature "
  69      "instance)"},
  70     {"variant_level", T_LONG, offsetof(DBusPyArray, variant_level),
  71      READONLY,
  72      "The number of nested variants wrapping the real data. "
  73      "0 if not in a variant."},
  74     {NULL},
  75 };
  76
  77 static void
  78 Array_tp_dealloc (DBusPyArray *self)
  79 {
  80     Py_XDECREF(self->signature);
  81     self->signature = NULL;
  82     (PyList_Type.tp_dealloc)((PyObject *)self);
  83 }
  84
  85 static PyObject *
  86 Array_tp_repr(DBusPyArray *self)
  87 {
  88     PyObject *parent_repr = (PyList_Type.tp_repr)((PyObject *)self);
  89     PyObject *sig_repr = PyObject_Repr(self->signature);
  90     PyObject *my_repr = NULL;
  91     long variant_level = self->variant_level;
  92
  93     if (!parent_repr) goto finally;
  94     if (!sig_repr) goto finally;
  95     if (variant_level > 0) {
  96         my_repr = PyString_FromFormat("%s(%s, signature=%s, "
  97                                       "variant_level=%ld)",
  98                                       self->super.ob_type->tp_name,
  99                                       PyString_AS_STRING(parent_repr),
 100                                       PyString_AS_STRING(sig_repr),
 101                                       variant_level);
 102     }
 103     else {
 104         my_repr = PyString_FromFormat("%s(%s, signature=%s)",
 105                                       self->super.ob_type->tp_name,
 106                                       PyString_AS_STRING(parent_repr),
 107                                       PyString_AS_STRING(sig_repr));
 108     }
 109 finally:
 110     Py_XDECREF(parent_repr);
 111     Py_XDECREF(sig_repr);
 112     return my_repr;
 113 }
 114
 115 static PyObject *
 116 Array_tp_new (PyTypeObject *cls, PyObject *args, PyObject *kwargs)
 117 {
 118     PyObject *variant_level = NULL;
 119     DBusPyArray *self = (DBusPyArray *)(PyList_Type.tp_new)(cls, args, kwargs);
 120
 121     /* variant_level is immutable, so handle it in __new__ rather than
 122     __init__ */
 123     if (!self) return NULL;
 124     Py_INCREF(Py_None);
 125     self->signature = Py_None;
 126     self->variant_level = 0;
 127     if (kwargs) {
 128         variant_level = PyDict_GetItem(kwargs, dbus_py_variant_level_const);
 129     }
 130     if (variant_level) {
 131         self->variant_level = PyInt_AsLong(variant_level);
 132         if (PyErr_Occurred()) {
 133             Py_DECREF((PyObject *)self);
 134             return NULL;
 135         }
 136     }
 137     return (PyObject *)self;
 138 }
 139
 140 static int
 141 Array_tp_init (DBusPyArray *self, PyObject *args, PyObject *kwargs)
 142 {
 143     PyObject *obj = dbus_py_empty_tuple;
 144     PyObject *signature = NULL;
 145     PyObject *tuple;
 146     PyObject *variant_level;
 147     /* variant_level is accepted but ignored - it's immutable, so
 148      * __new__ handles it */
 149     static char *argnames[] = {"iterable", "signature", "variant_level", NULL};
 150
 151     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:__init__", argnames,
 152                                      &obj, &signature, &variant_level)) {
 153         return -1;
 154     }
 155
 156   /* convert signature from a borrowed ref of unknown type to an owned ref
 157   of type Signature (or None) */
 158     if (!signature) signature = Py_None;
 159     if (signature == Py_None
 160         || PyObject_IsInstance(signature, (PyObject *)&DBusPySignature_Type)) {
 161         Py_INCREF(signature);
 162     }
 163     else {
 164         signature = PyObject_CallFunction((PyObject *)&DBusPySignature_Type,
 165                                           "(O)", signature);
 166         if (!signature) return -1;
 167     }
 168
 169     if (signature != Py_None) {
 170         const char *c_str = PyString_AS_STRING(signature);
 171
 172         if (!dbus_signature_validate_single(c_str, NULL)) {
 173             Py_DECREF(signature);
 174             PyErr_SetString(PyExc_ValueError,
 175                             "There must be exactly one complete type in "
 176                             "an Array's signature parameter");
 177             return -1;
 178         }
 179     }
 180
 181     tuple = Py_BuildValue("(O)", obj);
 182     if (!tuple) {
 183         Py_DECREF(signature);
 184         return -1;
 185     }
 186     if ((PyList_Type.tp_init)((PyObject *)self, tuple, NULL) < 0) {
 187         Py_DECREF(tuple);
 188         Py_DECREF(signature);
 189         return -1;
 190     }
 191     Py_DECREF(tuple);
 192
 193     Py_XDECREF(self->signature);
 194     self->signature = signature;
 195     return 0;
 196 }
 197
 198 PyTypeObject DBusPyArray_Type = {
 199     PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
 200     0,
 201     "dbus.Array",
 202     sizeof(DBusPyArray),
 203     0,
 204     (destructor)Array_tp_dealloc,           /* tp_dealloc */
 205     0,                                      /* tp_print */
 206     0,                                      /* tp_getattr */
 207     0,                                      /* tp_setattr */
 208     0,                                      /* tp_compare */
 209     (reprfunc)Array_tp_repr,                /* tp_repr */
 210     0,                                      /* tp_as_number */
 211     0,                                      /* tp_as_sequence */
 212     0,                                      /* tp_as_mapping */
 213     0,                                      /* tp_hash */
 214     0,                                      /* tp_call */
 215     0,                                      /* tp_str */
 216     0,                                      /* tp_getattro */
 217     0,                                      /* tp_setattro */
 218     0,                                      /* tp_as_buffer */
 219     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 220     Array_tp_doc,                           /* tp_doc */
 221     0,                                      /* tp_traverse */
 222     0,                                      /* tp_clear */
 223     0,                                      /* tp_richcompare */
 224     0,                                      /* tp_weaklistoffset */
 225     0,                                      /* tp_iter */
 226     0,                                      /* tp_iternext */
 227     0,                                      /* tp_methods */
 228     Array_tp_members,                       /* tp_members */
 229     0,                                      /* tp_getset */
 230     0,                                      /* tp_base */
 231     0,                                      /* tp_dict */
 232     0,                                      /* tp_descr_get */
 233     0,                                      /* tp_descr_set */
 234     0,                                      /* tp_dictoffset */
 235     (initproc)Array_tp_init,                /* tp_init */
 236     0,                                      /* tp_alloc */
 237     Array_tp_new,                           /* tp_new */
 238 };
 239
 240 /* Dict ============================================================= */
 241
 242 PyDoc_STRVAR(Dict_tp_doc,
 243 "An mapping whose keys are similar and whose values are similar,\n"
 244 "implemented as a subtype of dict.\n"
 245 "\n"
 246 "As currently implemented, a Dictionary behaves just like a dict, but\n"
 247 "with the addition of a ``signature`` property set by the constructor;\n"
 248 "conversion of its items to D-Bus types is only done when it's sent in\n"
 249 "a Message. This may change in future so validation is done earlier.\n"
 250 "\n"
 251 "Constructor::\n"
 252 "\n"
 253 "    Dictionary(mapping_or_iterable=(), signature=None, variant_level=0)\n"
 254 "\n"
 255 "``variant_level`` must be non-negative; the default is 0.\n"
 256 "\n"
 257 "``signature`` is either a string or None. If a string, it must consist\n"
 258 "of exactly two complete type signatures, representing the 'key' type\n"
 259 "(which must be a primitive type, i.e. one of \"bdginoqstuxy\")\n"
 260 "and the 'value' type. The signature of the whole Dictionary will be\n"
 261 "``a{xx}`` where ``xx`` is replaced by the given signature.\n"
 262 "\n"
 263 "If it is None (the default), when the Dictionary is sent over\n"
 264 "D-Bus, the key and value signatures will be guessed from an arbitrary\n"
 265 "element of the Dictionary.\n"
 266 "\n"
 267 ":IVariables:\n"
 268 "  `variant_level` : int\n"
 269 "    Indicates how many nested Variant containers this object\n"
 270 "    is contained in: if a message's wire format has a variant containing a\n"
 271 "    variant containing an array of DICT_ENTRY, this is represented in\n"
 272 "    Python by a Dictionary with variant_level==2.\n"
 273 );
 274
 275 static struct PyMemberDef Dict_tp_members[] = {
 276     {"signature", T_OBJECT, offsetof(DBusPyDict, signature), READONLY,
 277      "The D-Bus signature of each key in this Dictionary, followed by "
 278      "that of each value in this Dictionary, as a Signature instance."},
 279     {"variant_level", T_LONG, offsetof(DBusPyDict, variant_level),
 280      READONLY,
 281      "The number of nested variants wrapping the real data. "
 282      "0 if not in a variant."},
 283     {NULL},
 284 };
 285
 286 static void
 287 Dict_tp_dealloc (DBusPyDict *self)
 288 {
 289     Py_XDECREF(self->signature);
 290     self->signature = NULL;
 291     (PyDict_Type.tp_dealloc)((PyObject *)self);
 292 }
 293
 294 static PyObject *
 295 Dict_tp_repr(DBusPyDict *self)
 296 {
 297     PyObject *parent_repr = (PyDict_Type.tp_repr)((PyObject *)self);
 298     PyObject *sig_repr = PyObject_Repr(self->signature);
 299     PyObject *my_repr = NULL;
 300     long variant_level = self->variant_level;
 301
 302     if (!parent_repr) goto finally;
 303     if (!sig_repr) goto finally;
 304     if (variant_level > 0) {
 305         my_repr = PyString_FromFormat("%s(%s, signature=%s, "
 306                                       "variant_level=%ld)",
 307                                       self->super.ob_type->tp_name,
 308                                       PyString_AS_STRING(parent_repr),
 309                                       PyString_AS_STRING(sig_repr),
 310                                       variant_level);
 311     }
 312     else {
 313         my_repr = PyString_FromFormat("%s(%s, signature=%s)",
 314                                       self->super.ob_type->tp_name,
 315                                       PyString_AS_STRING(parent_repr),
 316                                       PyString_AS_STRING(sig_repr));
 317     }
 318 finally:
 319     Py_XDECREF(parent_repr);
 320     Py_XDECREF(sig_repr);
 321     return my_repr;
 322 }
 323
 324 static PyObject *
 325 Dict_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs)
 326 {
 327     DBusPyDict *self = (DBusPyDict *)(PyDict_Type.tp_new)(cls, args, kwargs);
 328     PyObject *variant_level = NULL;
 329
 330     /* variant_level is immutable, so handle it in __new__ rather than
 331     __init__ */
 332     if (!self) return NULL;
 333     Py_INCREF(Py_None);
 334     self->signature = Py_None;
 335     self->variant_level = 0;
 336     if (kwargs) {
 337         variant_level = PyDict_GetItem(kwargs, dbus_py_variant_level_const);
 338     }
 339     if (variant_level) {
 340         self->variant_level = PyInt_AsLong(variant_level);
 341         if (PyErr_Occurred()) {
 342             Py_DECREF((PyObject *)self);
 343             return NULL;
 344         }
 345     }
 346     return (PyObject *)self;
 347 }
 348
 349 static int
 350 Dict_tp_init(DBusPyDict *self, PyObject *args, PyObject *kwargs)
 351 {
 352     PyObject *obj = dbus_py_empty_tuple;
 353     PyObject *signature = NULL;
 354     PyObject *tuple;
 355     PyObject *variant_level;    /* ignored here - __new__ uses it */
 356     static char *argnames[] = {"mapping_or_iterable", "signature",
 357                                "variant_level", NULL};
 358
 359     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:__init__", argnames,
 360                                      &obj, &signature, &variant_level)) {
 361         return -1;
 362     }
 363
 364   /* convert signature from a borrowed ref of unknown type to an owned ref
 365   of type Signature (or None) */
 366     if (!signature) signature = Py_None;
 367     if (signature == Py_None
 368         || PyObject_IsInstance(signature, (PyObject *)&DBusPySignature_Type)) {
 369         Py_INCREF(signature);
 370     }
 371     else {
 372         signature = PyObject_CallFunction((PyObject *)&DBusPySignature_Type,
 373                                           "(O)", signature);
 374         if (!signature) return -1;
 375     }
 376
 377     if (signature != Py_None) {
 378         const char *c_str = PyString_AS_STRING(signature);
 379
 380         switch (c_str[0]) {
 381             case DBUS_TYPE_BYTE:
 382             case DBUS_TYPE_BOOLEAN:
 383             case DBUS_TYPE_INT16:
 384             case DBUS_TYPE_UINT16:
 385             case DBUS_TYPE_INT32:
 386             case DBUS_TYPE_UINT32:
 387             case DBUS_TYPE_INT64:
 388             case DBUS_TYPE_UINT64:
 389             case DBUS_TYPE_DOUBLE:
 390 #ifdef WITH_DBUS_FLOAT32
 391             case DBUS_TYPE_FLOAT:
 392 #endif
 393             case DBUS_TYPE_STRING:
 394             case DBUS_TYPE_OBJECT_PATH:
 395             case DBUS_TYPE_SIGNATURE:
 396                 break;
 397             default:
 398                 Py_DECREF(signature);
 399                 PyErr_SetString(PyExc_ValueError,
 400                                 "The key type in a Dictionary's signature "
 401                                 "must be a primitive type");
 402                 return -1;
 403         }
 404
 405         if (!dbus_signature_validate_single(c_str + 1, NULL)) {
 406             Py_DECREF(signature);
 407             PyErr_SetString(PyExc_ValueError,
 408                             "There must be exactly two complete types in "
 409                             "a Dictionary's signature parameter");
 410             return -1;
 411         }
 412     }
 413
 414     tuple = Py_BuildValue("(O)", obj);
 415     if (!tuple) {
 416         Py_DECREF(signature);
 417         return -1;
 418     }
 419
 420     if ((PyDict_Type.tp_init((PyObject *)self, tuple, NULL)) < 0) {
 421         Py_DECREF(tuple);
 422         Py_DECREF(signature);
 423         return -1;
 424     }
 425     Py_DECREF(tuple);
 426
 427     Py_XDECREF(self->signature);
 428     self->signature = signature;
 429     return 0;
 430 }
 431
 432 PyTypeObject DBusPyDict_Type = {
 433     PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
 434     0,
 435     "dbus.Dictionary",
 436     sizeof(DBusPyDict),
 437     0,
 438     (destructor)Dict_tp_dealloc,            /* tp_dealloc */
 439     0,                                      /* tp_print */
 440     0,                                      /* tp_getattr */
 441     0,                                      /* tp_setattr */
 442     0,                                      /* tp_compare */
 443     (reprfunc)Dict_tp_repr,                 /* tp_repr */
 444     0,                                      /* tp_as_number */
 445     0,                                      /* tp_as_sequence */
 446     0,                                      /* tp_as_mapping */
 447     0,                                      /* tp_hash */
 448     0,                                      /* tp_call */
 449     0,                                      /* tp_str */
 450     0,                                      /* tp_getattro */
 451     0,                                      /* tp_setattro */
 452     0,                                      /* tp_as_buffer */
 453     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 454     Dict_tp_doc,                            /* tp_doc */
 455     0,                                      /* tp_traverse */
 456     0,                                      /* tp_clear */
 457     0,                                      /* tp_richcompare */
 458     0,                                      /* tp_weaklistoffset */
 459     0,                                      /* tp_iter */
 460     0,                                      /* tp_iternext */
 461     0,                                      /* tp_methods */
 462     Dict_tp_members,                        /* tp_members */
 463     0,                                      /* tp_getset */
 464     0,                                      /* tp_base */
 465     0,                                      /* tp_dict */
 466     0,                                      /* tp_descr_get */
 467     0,                                      /* tp_descr_set */
 468     0,                                      /* tp_dictoffset */
 469     (initproc)Dict_tp_init,                 /* tp_init */
 470     0,                                      /* tp_alloc */
 471     Dict_tp_new,                            /* tp_new */
 472 };
 473
 474 /* Struct =========================================================== */
 475
 476 static PyObject *struct_signatures;
 477
 478 PyDoc_STRVAR(Struct_tp_doc,
 479 "An structure containing items of possibly distinct types.\n"
 480 "\n"
 481 "Constructor::\n"
 482 "\n"
 483 "    dbus.Struct(iterable, signature=None, variant_level=0) -> Struct\n"
 484 "\n"
 485 "D-Bus structs may not be empty, so the iterable argument is required and\n"
 486 "may not be an empty iterable.\n"
 487 "\n"
 488 "``signature`` is either None, or a string representing the contents of the\n"
 489 "struct as one or more complete type signatures. The overall signature of\n"
 490 "the struct will be the given signature enclosed in parentheses, ``()``.\n"
 491 "\n"
 492 "If the signature is None (default) it will be guessed\n"
 493 "from the types of the items during construction.\n"
 494 "\n"
 495 "``variant_level`` must be non-negative; the default is 0.\n"
 496 "\n"
 497 ":IVariables:\n"
 498 "  `variant_level` : int\n"
 499 "    Indicates how many nested Variant containers this object\n"
 500 "    is contained in: if a message's wire format has a variant containing a\n"
 501 "    variant containing a struct, this is represented in Python by a\n"
 502 "    Struct with variant_level==2.\n"
 503 );
 504
 505 static PyObject *
 506 Struct_tp_repr(PyObject *self)
 507 {
 508     PyObject *parent_repr = (PyTuple_Type.tp_repr)((PyObject *)self);
 509     PyObject *sig;
 510     PyObject *sig_repr = NULL;
 511     PyObject *key;
 512     long variant_level;
 513     PyObject *my_repr = NULL;
 514
 515     if (!parent_repr) goto finally;
 516     key = PyLong_FromVoidPtr(self);
 517     if (!key) goto finally;
 518     sig = PyDict_GetItem(struct_signatures, key);
 519     Py_DECREF(key);
 520     if (!sig) sig = Py_None;
 521     sig_repr = PyObject_Repr(sig);
 522     if (!sig_repr) goto finally;
 523     variant_level = dbus_py_variant_level_get(self);
 524     if (variant_level > 0) {
 525         my_repr = PyString_FromFormat("%s(%s, signature=%s, "
 526                                       "variant_level=%ld)",
 527                                       self->ob_type->tp_name,
 528                                       PyString_AS_STRING(parent_repr),
 529                                       PyString_AS_STRING(sig_repr),
 530                                       variant_level);
 531     }
 532     else {
 533         my_repr = PyString_FromFormat("%s(%s, signature=%s)",
 534                                       self->ob_type->tp_name,
 535                                       PyString_AS_STRING(parent_repr),
 536                                       PyString_AS_STRING(sig_repr));
 537     }
 538
 539 finally:
 540     Py_XDECREF(parent_repr);
 541     Py_XDECREF(sig_repr);
 542     return my_repr;
 543 }
 544
 545 static PyObject *
 546 Struct_tp_new (PyTypeObject *cls, PyObject *args, PyObject *kwargs)
 547 {
 548     PyObject *signature = NULL;
 549     long variantness = 0;
 550     PyObject *self, *key;
 551     static char *argnames[] = {"signature", "variant_level", NULL};
 552
 553     if (PyTuple_Size(args) != 1) {
 554         PyErr_SetString(PyExc_TypeError,
 555                         "__new__ takes exactly one positional parameter");
 556         return NULL;
 557     }
 558     if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs,
 559                                      "|Ol:__new__", argnames,
 560                                      &signature, &variantness)) {
 561         return NULL;
 562     }
 563     if (variantness < 0) {
 564         PyErr_SetString(PyExc_ValueError,
 565                         "variant_level must be non-negative");
 566         return NULL;
 567     }
 568
 569     self = (PyTuple_Type.tp_new)(cls, args, NULL);
 570     if (!self)
 571         return NULL;
 572     if (PyTuple_Size(self) < 1) {
 573         PyErr_SetString(PyExc_ValueError, "D-Bus structs may not be empty");
 574         Py_DECREF(self);
 575         return NULL;
 576     }
 577
 578     if (!dbus_py_variant_level_set(self, variantness)) {
 579         Py_DECREF(self);
 580         return NULL;
 581     }
 582
 583     /* convert signature from a borrowed ref of unknown type to an owned ref
 584     of type Signature (or None) */
 585     if (!signature) signature = Py_None;
 586     if (signature == Py_None
 587         || PyObject_IsInstance(signature, (PyObject *)&DBusPySignature_Type)) {
 588         Py_INCREF(signature);
 589     }
 590     else {
 591         signature = PyObject_CallFunction((PyObject *)&DBusPySignature_Type,
 592                                           "(O)", signature);
 593         if (!signature) {
 594             Py_DECREF(self);
 595             return NULL;
 596         }
 597     }
 598
 599     key = PyLong_FromVoidPtr(self);
 600     if (!key) {
 601         Py_DECREF(self);
 602         Py_DECREF(signature);
 603         return NULL;
 604     }
 605     if (PyDict_SetItem(struct_signatures, key, signature) < 0) {
 606         Py_DECREF(key);
 607         Py_DECREF(self);
 608         Py_DECREF(signature);
 609         return NULL;
 610     }
 611
 612     Py_DECREF(key);
 613     Py_DECREF(signature);
 614     return self;
 615 }
 616
 617 static void
 618 Struct_tp_dealloc(PyObject *self)
 619 {
 620     PyObject *et, *ev, *etb, *key;
 621
 622     dbus_py_variant_level_clear(self);
 623     PyErr_Fetch(&et, &ev, &etb);
 624
 625     key = PyLong_FromVoidPtr(self);
 626     if (key) {
 627         if (PyDict_GetItem(struct_signatures, key)) {
 628             if (PyDict_DelItem(struct_signatures, key) < 0) {
 629                 /* should never happen */
 630                 PyErr_WriteUnraisable(self);
 631             }
 632         }
 633         Py_DECREF(key);
 634     }
 635     else {
 636         /* not enough memory to free all the memory... leak the signature,
 637          * there's not much else we could do here */
 638         PyErr_WriteUnraisable(self);
 639     }
 640
 641     PyErr_Restore(et, ev, etb);
 642     (PyTuple_Type.tp_dealloc)(self);
 643 }
 644
 645 PyObject *
 646 Struct_tp_getattro(PyObject *obj, PyObject *name)
 647 {
 648     PyObject *key, *value;
 649
 650     if (PyString_Check(name)) {
 651         Py_INCREF(name);
 652     }
 653     else if (PyUnicode_Check(name)) {
 654         name = PyUnicode_AsEncodedString(name, NULL, NULL);
 655         if (!name) {
 656             return NULL;
 657         }
 658     }
 659     else {
 660         PyErr_SetString(PyExc_TypeError, "attribute name must be string");
 661         return NULL;
 662     }
 663
 664     if (strcmp(PyString_AS_STRING(name), "signature")) {
 665         value = dbus_py_variant_level_getattro(obj, name);
 666         Py_DECREF(name);
 667         return value;
 668     }
 669
 670     Py_DECREF(name);
 671
 672     key = PyLong_FromVoidPtr(obj);
 673
 674     if (!key) {
 675         return NULL;
 676     }
 677
 678     value = PyDict_GetItem(struct_signatures, key);
 679     Py_DECREF(key);
 680
 681     if (!value)
 682         value = Py_None;
 683     Py_INCREF(value);
 684     return value;
 685 }
 686
 687 PyTypeObject DBusPyStruct_Type = {
 688     PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type))
 689     0,
 690     "dbus.Struct",
 691     0,
 692     0,
 693     Struct_tp_dealloc,                      /* tp_dealloc */
 694     0,                                      /* tp_print */
 695     0,                                      /* tp_getattr */
 696     0,                                      /* tp_setattr */
 697     0,                                      /* tp_compare */
 698     (reprfunc)Struct_tp_repr,               /* tp_repr */
 699     0,                                      /* tp_as_number */
 700     0,                                      /* tp_as_sequence */
 701     0,                                      /* tp_as_mapping */
 702     0,                                      /* tp_hash */
 703     0,                                      /* tp_call */
 704     0,                                      /* tp_str */
 705     Struct_tp_getattro,                     /* tp_getattro */
 706     dbus_py_immutable_setattro,             /* tp_setattro */
 707     0,                                      /* tp_as_buffer */
 708     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
 709     Struct_tp_doc,                          /* tp_doc */
 710     0,                                      /* tp_traverse */
 711     0,                                      /* tp_clear */
 712     0,                                      /* tp_richcompare */
 713     0,                                      /* tp_weaklistoffset */
 714     0,                                      /* tp_iter */
 715     0,                                      /* tp_iternext */
 716     0,                                      /* tp_methods */
 717     0,                                      /* tp_members */
 718     0,                                      /* tp_getset */
 719     0,                                      /* tp_base */
 720     0,                                      /* tp_dict */
 721     0,                                      /* tp_descr_get */
 722     0,                                      /* tp_descr_set */
 723     0,                                      /* tp_dictoffset */
 724     0,                                      /* tp_init */
 725     0,                                      /* tp_alloc */
 726     Struct_tp_new,                          /* tp_new */
 727 };
 728
 729 dbus_bool_t
 730 dbus_py_init_container_types(void)
 731 {
 732     struct_signatures = PyDict_New();
 733     if (!struct_signatures) return 0;
 734
 735     DBusPyArray_Type.tp_base = &PyList_Type;
 736     if (PyType_Ready(&DBusPyArray_Type) < 0) return 0;
 737     DBusPyArray_Type.tp_print = NULL;
 738
 739     DBusPyDict_Type.tp_base = &PyDict_Type;
 740     if (PyType_Ready(&DBusPyDict_Type) < 0) return 0;
 741     DBusPyDict_Type.tp_print = NULL;
 742
 743     DBusPyStruct_Type.tp_base = &PyTuple_Type;
 744     if (PyType_Ready(&DBusPyStruct_Type) < 0) return 0;
 745     DBusPyStruct_Type.tp_print = NULL;
 746
 747     return 1;
 748 }
 749
 750 dbus_bool_t
 751 dbus_py_insert_container_types(PyObject *this_module)
 752 {
 753     Py_INCREF(&DBusPyArray_Type);
 754     if (PyModule_AddObject(this_module, "Array",
 755                            (PyObject *)&DBusPyArray_Type) < 0) return 0;
 756
 757     Py_INCREF(&DBusPyDict_Type);
 758     if (PyModule_AddObject(this_module, "Dictionary",
 759                            (PyObject *)&DBusPyDict_Type) < 0) return 0;
 760
 761     Py_INCREF(&DBusPyStruct_Type);
 762     if (PyModule_AddObject(this_module, "Struct",
 763                            (PyObject *)&DBusPyStruct_Type) < 0) return 0;
 764
 765     return 1;
 766 }
 767
 768 /* vim:set ft=c cino< sw=4 sts=4 et: */
 769