11#if PY_VERSION_HEX >= 0x03040000
12#define _COLLECTIONS_ABC "_collections_abc"
13#elif PY_VERSION_HEX >= 0x03030000
14#define _COLLECTIONS_ABC "collections.abc"
16#define _COLLECTIONS_ABC "_abcoll"
19static void _register_collection(PyTypeObject *type,
const char *abc) {
20 PyObject *sys_modules = PyImport_GetModuleDict();
21 if (sys_modules !=
nullptr) {
22 PyObject *
module = PyDict_GetItemString(sys_modules, _COLLECTIONS_ABC);
23 if (module !=
nullptr) {
24 PyObject *dict = PyModule_GetDict(module);
25 if (module !=
nullptr) {
26#if PY_MAJOR_VERSION >= 3
27 static PyObject *register_str = PyUnicode_InternFromString(
"register");
29 static PyObject *register_str = PyString_InternFromString(
"register");
31 PyObject *sequence = PyDict_GetItemString(dict, abc);
32 if (sequence !=
nullptr) {
33 if (PyObject_CallMethodObjArgs(sequence, register_str, (PyObject *)type,
nullptr) ==
nullptr) {
46static void Dtool_WrapperBase_dealloc(PyObject *self) {
47 Dtool_WrapperBase *wrap = (Dtool_WrapperBase *)self;
49 Py_XDECREF(wrap->_self);
50 Py_TYPE(self)->tp_free(self);
53static PyObject *Dtool_WrapperBase_repr(PyObject *self) {
54 Dtool_WrapperBase *wrap = (Dtool_WrapperBase *)self;
55 nassertr(wrap,
nullptr);
57 PyObject *repr = PyObject_Repr(wrap->_self);
59#if PY_MAJOR_VERSION >= 3
60 result = PyUnicode_FromFormat(
"<%s[] of %s>", wrap->_name, PyUnicode_AsUTF8(repr));
62 result = PyString_FromFormat(
"<%s[] of %s>", wrap->_name, PyString_AS_STRING(repr));
68static PyObject *Dtool_SequenceWrapper_repr(PyObject *self) {
69 Dtool_SequenceWrapper *wrap = (Dtool_SequenceWrapper *)self;
70 nassertr(wrap,
nullptr);
73 if (wrap->_len_func !=
nullptr) {
74 len = wrap->_len_func(wrap->_base._self);
78 PyErr_Restore(
nullptr,
nullptr,
nullptr);
79 return Dtool_WrapperBase_repr(self);
82 PyObject *repr = PyObject_Repr(wrap->_base._self);
84#if PY_MAJOR_VERSION >= 3
85 result = PyUnicode_FromFormat(
"<%s[%zd] of %s>", wrap->_base._name, len, PyUnicode_AsUTF8(repr));
87 result = PyString_FromFormat(
"<%s[%zd] of %s>", wrap->_base._name, len, PyString_AS_STRING(repr));
93static Py_ssize_t Dtool_SequenceWrapper_length(PyObject *self) {
94 Dtool_SequenceWrapper *wrap = (Dtool_SequenceWrapper *)self;
96 if (wrap->_len_func !=
nullptr) {
97 return wrap->_len_func(wrap->_base._self);
99 Dtool_Raise_TypeError(
"property does not support len()");
104static PyObject *Dtool_SequenceWrapper_getitem(PyObject *self, Py_ssize_t index) {
105 Dtool_SequenceWrapper *wrap = (Dtool_SequenceWrapper *)self;
106 nassertr(wrap,
nullptr);
107 nassertr(wrap->_getitem_func,
nullptr);
108 return wrap->_getitem_func(wrap->_base._self, index);
114static int Dtool_SequenceWrapper_contains(PyObject *self, PyObject *value) {
115 Dtool_SequenceWrapper *wrap = (Dtool_SequenceWrapper *)self;
117 nassertr(wrap->_len_func, -1);
118 nassertr(wrap->_getitem_func, -1);
120 Py_ssize_t length = wrap->_len_func(wrap->_base._self);
124 for (Py_ssize_t index = 0; index < length; ++index) {
125 PyObject *item = wrap->_getitem_func(wrap->_base._self, index);
126 if (item !=
nullptr) {
127 int cmp = PyObject_RichCompareBool(item, value, Py_EQ);
145static PyObject *Dtool_SequenceWrapper_index(PyObject *self, PyObject *value) {
146 Dtool_SequenceWrapper *wrap = (Dtool_SequenceWrapper *)self;
147 nassertr(wrap,
nullptr);
148 nassertr(wrap->_len_func,
nullptr);
149 nassertr(wrap->_getitem_func,
nullptr);
151 Py_ssize_t length = wrap->_len_func(wrap->_base._self);
155 for (Py_ssize_t index = 0; index < length; ++index) {
156 PyObject *item = wrap->_getitem_func(wrap->_base._self, index);
157 if (item !=
nullptr) {
158 int cmp = PyObject_RichCompareBool(item, value, Py_EQ);
170 return PyErr_Format(PyExc_ValueError,
"%s.index() did not find value", wrap->_base._name);
177static PyObject *Dtool_SequenceWrapper_count(PyObject *self, PyObject *value) {
178 Dtool_SequenceWrapper *wrap = (Dtool_SequenceWrapper *)self;
179 nassertr(wrap,
nullptr);
180 Py_ssize_t index = 0;
181 if (wrap->_len_func !=
nullptr) {
182 index = wrap->_len_func(wrap->_base._self);
184 return Dtool_Raise_TypeError(
"property does not support count()");
188 nassertr(wrap->_getitem_func,
nullptr);
191 PyObject *item = wrap->_getitem_func(wrap->_base._self, index);
192 if (item ==
nullptr) {
195 int cmp = PyObject_RichCompareBool(item, value, Py_EQ);
203#if PY_MAJOR_VERSION >= 3
204 return PyLong_FromLong(count);
206 return PyInt_FromLong(count);
213static int Dtool_MutableSequenceWrapper_setitem(PyObject *self, Py_ssize_t index, PyObject *value) {
214 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)self;
216 if (wrap->_setitem_func !=
nullptr) {
217 return wrap->_setitem_func(wrap->_base._self, index, value);
219 Dtool_Raise_TypeError(
"property does not support item assignment");
228static PyObject *Dtool_MutableSequenceWrapper_clear(PyObject *self, PyObject *) {
229 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)self;
230 nassertr(wrap,
nullptr);
231 Py_ssize_t index = 0;
232 if (wrap->_len_func !=
nullptr && wrap->_setitem_func !=
nullptr) {
233 index = wrap->_len_func(wrap->_base._self);
235 return Dtool_Raise_TypeError(
"property does not support clear()");
242 if (wrap->_setitem_func(wrap->_base._self, index,
nullptr) != 0) {
254static PyObject *Dtool_MutableSequenceWrapper_remove(PyObject *self, PyObject *value) {
255 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)self;
256 nassertr(wrap,
nullptr);
257 Py_ssize_t length = 0;
258 if (wrap->_len_func !=
nullptr && wrap->_setitem_func !=
nullptr) {
259 length = wrap->_len_func(wrap->_base._self);
261 return Dtool_Raise_TypeError(
"property does not support remove()");
266 nassertr(wrap->_getitem_func,
nullptr);
267 for (Py_ssize_t index = 0; index < length; ++index) {
268 PyObject *item = wrap->_getitem_func(wrap->_base._self, index);
269 if (item !=
nullptr) {
270 int cmp = PyObject_RichCompareBool(item, value, Py_EQ);
272 if (wrap->_setitem_func(wrap->_base._self, index,
nullptr) == 0) {
287 return PyErr_Format(PyExc_ValueError,
"%s.remove() did not find value", wrap->_base._name);
295static PyObject *Dtool_MutableSequenceWrapper_pop(PyObject *self, PyObject *args) {
296 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)self;
297 nassertr(wrap,
nullptr);
298 if (wrap->_getitem_func ==
nullptr || wrap->_setitem_func ==
nullptr ||
299 wrap->_len_func ==
nullptr) {
300 return Dtool_Raise_TypeError(
"property does not support pop()");
303 Py_ssize_t length = wrap->_len_func(wrap->_base._self);
305 switch (PyTuple_GET_SIZE(args)) {
310 index = PyNumber_AsSsize_t(PyTuple_GET_ITEM(args, 0), PyExc_IndexError);
311 if (index == -1 && _PyErr_OCCURRED()) {
319 return Dtool_Raise_TypeError(
"pop([i=-1]) takes 0 or 1 arguments");
323 return PyErr_Format(PyExc_IndexError,
"%s.pop() from empty sequence", wrap->_base._name);
327 PyObject *value = wrap->_getitem_func(wrap->_base._self, index);
328 if (value !=
nullptr) {
329 if (wrap->_setitem_func(wrap->_base._self, index,
nullptr) != 0) {
341static PyObject *Dtool_MutableSequenceWrapper_append(PyObject *self, PyObject *arg) {
342 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)self;
343 nassertr(wrap,
nullptr);
344 if (wrap->_insert_func ==
nullptr) {
345 return Dtool_Raise_TypeError(
"property does not support append()");
347 return wrap->_insert_func(wrap->_base._self, (
size_t)-1, arg);
354static PyObject *Dtool_MutableSequenceWrapper_insert(PyObject *self, PyObject *args) {
355 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)self;
356 nassertr(wrap,
nullptr);
357 if (wrap->_insert_func ==
nullptr) {
358 return Dtool_Raise_TypeError(
"property does not support insert()");
360 if (PyTuple_GET_SIZE(args) != 2) {
361 return Dtool_Raise_TypeError(
"insert() takes exactly 2 arguments");
363 Py_ssize_t index = PyNumber_AsSsize_t(PyTuple_GET_ITEM(args, 0), PyExc_IndexError);
364 if (index == -1 && _PyErr_OCCURRED()) {
368 if (wrap->_len_func !=
nullptr) {
369 index += wrap->_len_func(wrap->_base._self);
371 return PyErr_Format(PyExc_TypeError,
"%s.insert() does not support negative indices", wrap->_base._name);
374 return wrap->_insert_func(wrap->_base._self, (
size_t)std::max(index, (Py_ssize_t)0), PyTuple_GET_ITEM(args, 1));
384static PyObject *Dtool_MutableSequenceWrapper_extend(PyObject *self, PyObject *arg) {
385 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)self;
386 nassertr(wrap,
nullptr);
387 if (wrap->_insert_func ==
nullptr) {
388 return Dtool_Raise_TypeError(
"property does not support extend()");
390 PyObject *iter = PyObject_GetIter(arg);
391 if (iter ==
nullptr) {
394 PyObject *next = PyIter_Next(iter);
395 PyObject *retval =
nullptr;
396 while (next !=
nullptr) {
397 retval = wrap->_insert_func(wrap->_base._self, (
size_t)-1, next);
399 if (retval ==
nullptr) {
404 next = PyIter_Next(iter);
415static int Dtool_MappingWrapper_contains(PyObject *self, PyObject *key) {
416 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
418 nassertr(wrap->_getitem_func, -1);
419 PyObject *value = wrap->_getitem_func(wrap->_base._self, key);
420 if (value !=
nullptr) {
423 }
else if (_PyErr_OCCURRED() == PyExc_KeyError ||
424 _PyErr_OCCURRED() == PyExc_TypeError) {
425 PyErr_Restore(
nullptr,
nullptr,
nullptr);
432static PyObject *Dtool_MappingWrapper_getitem(PyObject *self, PyObject *key) {
433 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
434 nassertr(wrap,
nullptr);
435 nassertr(wrap->_getitem_func,
nullptr);
436 return wrap->_getitem_func(wrap->_base._self, key);
443static PyObject *Dtool_MappingWrapper_iter(PyObject *self) {
444 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
445 nassertr(wrap,
nullptr);
447 if (wrap->_keys._len_func ==
nullptr || wrap->_keys._getitem_func ==
nullptr) {
448 return PyErr_Format(PyExc_TypeError,
"%s is not iterable", wrap->_base._name);
451 Dtool_SequenceWrapper *keys = Dtool_NewSequenceWrapper(wrap->_base._self, wrap->_base._name);
452 if (keys !=
nullptr) {
453 keys->_len_func = wrap->_keys._len_func;
454 keys->_getitem_func = wrap->_keys._getitem_func;
455 return PySeqIter_New((PyObject *)keys);
466static PyObject *Dtool_MappingWrapper_get(PyObject *self, PyObject *args) {
467 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
468 nassertr(wrap,
nullptr);
469 nassertr(wrap->_getitem_func,
nullptr);
470 Py_ssize_t size = PyTuple_GET_SIZE(args);
471 if (size != 1 && size != 2) {
472 return PyErr_Format(PyExc_TypeError,
"%s.get() takes 1 or 2 arguments", wrap->_base._name);
474 PyObject *defvalue = Py_None;
476 defvalue = PyTuple_GET_ITEM(args, 1);
478 PyObject *key = PyTuple_GET_ITEM(args, 0);
479 PyObject *value = wrap->_getitem_func(wrap->_base._self, key);
480 if (value !=
nullptr) {
482 }
else if (_PyErr_OCCURRED() == PyExc_KeyError) {
483 PyErr_Restore(
nullptr,
nullptr,
nullptr);
494static PyObject *Dtool_MappingWrapper_Keys_repr(PyObject *self) {
495 Dtool_WrapperBase *wrap = (Dtool_WrapperBase *)self;
496 nassertr(wrap,
nullptr);
498 PyObject *repr = PyObject_Repr(wrap->_self);
500#if PY_MAJOR_VERSION >= 3
501 result = PyUnicode_FromFormat(
"<%s.keys() of %s>", wrap->_name, PyUnicode_AsUTF8(repr));
503 result = PyString_FromFormat(
"<%s.keys() of %s>", wrap->_name, PyString_AS_STRING(repr));
512static PyObject *Dtool_MappingWrapper_keys(PyObject *self, PyObject *) {
513 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
514 nassertr(wrap,
nullptr);
516 if (wrap->_keys._len_func ==
nullptr || wrap->_keys._getitem_func ==
nullptr) {
517 return Dtool_Raise_TypeError(
"property does not support keys()");
520 Dtool_MappingWrapper *keys = (Dtool_MappingWrapper *)PyObject_MALLOC(
sizeof(Dtool_MappingWrapper));
521 if (keys ==
nullptr) {
522 return PyErr_NoMemory();
525 static PySequenceMethods seq_methods = {
526 Dtool_SequenceWrapper_length,
529 Dtool_SequenceWrapper_getitem,
533 Dtool_SequenceWrapper_contains,
538 static PyTypeObject wrapper_type = {
539 PyVarObject_HEAD_INIT(
nullptr, 0)
541 sizeof(Dtool_SequenceWrapper),
543 Dtool_WrapperBase_dealloc,
548 Dtool_MappingWrapper_Keys_repr,
555 PyObject_GenericGetAttr,
556 PyObject_GenericSetAttr,
558 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
586#
if PY_VERSION_HEX >= 0x03040000
589#
if PY_VERSION_HEX >= 0x03080000
594 static bool registered =
false;
598 if (PyType_Ready(&wrapper_type) < 0) {
603 _register_collection((PyTypeObject *)&wrapper_type,
"MappingView");
606 (void)PyObject_INIT(keys, &wrapper_type);
607 Py_XINCREF(wrap->_base._self);
608 keys->_base._self = wrap->_base._self;
609 keys->_base._name = wrap->_base._name;
610 keys->_keys._len_func = wrap->_keys._len_func;
611 keys->_keys._getitem_func = wrap->_keys._getitem_func;
612 keys->_getitem_func = wrap->_getitem_func;
613 keys->_setitem_func =
nullptr;
614 return (PyObject *)keys;
620static PyObject *Dtool_MappingWrapper_Values_repr(PyObject *self) {
621 Dtool_WrapperBase *wrap = (Dtool_WrapperBase *)self;
622 nassertr(wrap,
nullptr);
624 PyObject *repr = PyObject_Repr(wrap->_self);
626#if PY_MAJOR_VERSION >= 3
627 result = PyUnicode_FromFormat(
"<%s.values() of %s>", wrap->_name, PyUnicode_AsUTF8(repr));
629 result = PyString_FromFormat(
"<%s.values() of %s>", wrap->_name, PyString_AS_STRING(repr));
635static PyObject *Dtool_MappingWrapper_Values_getitem(PyObject *self, Py_ssize_t index) {
636 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
637 nassertr(wrap,
nullptr);
638 nassertr(wrap->_keys._getitem_func,
nullptr);
640 PyObject *key = wrap->_keys._getitem_func(wrap->_base._self, index);
641 if (key !=
nullptr) {
642 PyObject *value = wrap->_getitem_func(wrap->_base._self, key);
652static PyObject *Dtool_MappingWrapper_values(PyObject *self, PyObject *) {
653 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
654 nassertr(wrap,
nullptr);
655 nassertr(wrap->_getitem_func,
nullptr);
657 if (wrap->_keys._len_func ==
nullptr || wrap->_keys._getitem_func ==
nullptr) {
658 return Dtool_Raise_TypeError(
"property does not support values()");
661 Dtool_MappingWrapper *values = (Dtool_MappingWrapper *)PyObject_MALLOC(
sizeof(Dtool_MappingWrapper));
662 if (values ==
nullptr) {
663 return PyErr_NoMemory();
666 static PySequenceMethods seq_methods = {
667 Dtool_SequenceWrapper_length,
670 Dtool_MappingWrapper_Values_getitem,
674 Dtool_MappingWrapper_contains,
679 static PyTypeObject wrapper_type = {
680 PyVarObject_HEAD_INIT(
nullptr, 0)
682 sizeof(Dtool_MappingWrapper),
684 Dtool_WrapperBase_dealloc,
689 Dtool_MappingWrapper_Values_repr,
696 PyObject_GenericGetAttr,
697 PyObject_GenericSetAttr,
699 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
727#
if PY_VERSION_HEX >= 0x03040000
730#
if PY_VERSION_HEX >= 0x03080000
735 static bool registered =
false;
739 if (PyType_Ready(&wrapper_type) < 0) {
744 _register_collection((PyTypeObject *)&wrapper_type,
"ValuesView");
747 (void)PyObject_INIT(values, &wrapper_type);
748 Py_XINCREF(wrap->_base._self);
749 values->_base._self = wrap->_base._self;
750 values->_base._name = wrap->_base._name;
751 values->_keys._len_func = wrap->_keys._len_func;
752 values->_keys._getitem_func = wrap->_keys._getitem_func;
753 values->_getitem_func = wrap->_getitem_func;
754 values->_setitem_func =
nullptr;
755 return (PyObject *)values;
761static PyObject *Dtool_MappingWrapper_Items_repr(PyObject *self) {
762 Dtool_WrapperBase *wrap = (Dtool_WrapperBase *)self;
763 nassertr(wrap,
nullptr);
765 PyObject *repr = PyObject_Repr(wrap->_self);
767#if PY_MAJOR_VERSION >= 3
768 result = PyUnicode_FromFormat(
"<%s.items() of %s>", wrap->_name, PyUnicode_AsUTF8(repr));
770 result = PyString_FromFormat(
"<%s.items() of %s>", wrap->_name, PyString_AS_STRING(repr));
776static PyObject *Dtool_MappingWrapper_Items_getitem(PyObject *self, Py_ssize_t index) {
777 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
778 nassertr(wrap,
nullptr);
779 nassertr(wrap->_keys._getitem_func,
nullptr);
781 PyObject *key = wrap->_keys._getitem_func(wrap->_base._self, index);
782 if (key !=
nullptr) {
783 PyObject *value = wrap->_getitem_func(wrap->_base._self, key);
784 if (value !=
nullptr) {
786 PyObject *item = PyTuple_New(2);
787 PyTuple_SET_ITEM(item, 0, key);
788 PyTuple_SET_ITEM(item, 1, value);
801static PyObject *Dtool_MappingWrapper_items(PyObject *self, PyObject *) {
802 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
803 nassertr(wrap,
nullptr);
804 nassertr(wrap->_getitem_func,
nullptr);
806 if (wrap->_keys._len_func ==
nullptr || wrap->_keys._getitem_func ==
nullptr) {
807 return Dtool_Raise_TypeError(
"property does not support items()");
810 Dtool_MappingWrapper *items = (Dtool_MappingWrapper *)PyObject_MALLOC(
sizeof(Dtool_MappingWrapper));
811 if (items ==
nullptr) {
812 return PyErr_NoMemory();
815 static PySequenceMethods seq_methods = {
816 Dtool_SequenceWrapper_length,
819 Dtool_MappingWrapper_Items_getitem,
823 Dtool_MappingWrapper_contains,
828 static PyTypeObject wrapper_type = {
829 PyVarObject_HEAD_INIT(
nullptr, 0)
831 sizeof(Dtool_MappingWrapper),
833 Dtool_WrapperBase_dealloc,
838 Dtool_MappingWrapper_Items_repr,
845 PyObject_GenericGetAttr,
846 PyObject_GenericSetAttr,
848 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
876#
if PY_VERSION_HEX >= 0x03040000
879#
if PY_VERSION_HEX >= 0x03080000
884 static bool registered =
false;
888 if (PyType_Ready(&wrapper_type) < 0) {
893 _register_collection((PyTypeObject *)&wrapper_type,
"MappingView");
896 (void)PyObject_INIT(items, &wrapper_type);
897 Py_XINCREF(wrap->_base._self);
898 items->_base._self = wrap->_base._self;
899 items->_base._name = wrap->_base._name;
900 items->_keys._len_func = wrap->_keys._len_func;
901 items->_keys._getitem_func = wrap->_keys._getitem_func;
902 items->_getitem_func = wrap->_getitem_func;
903 items->_setitem_func =
nullptr;
904 return (PyObject *)items;
910static int Dtool_MutableMappingWrapper_setitem(PyObject *self, PyObject *key, PyObject *value) {
911 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
912 nassertr(wrap->_setitem_func !=
nullptr, -1);
913 return wrap->_setitem_func(wrap->_base._self, key, value);
920static PyObject *Dtool_MutableMappingWrapper_pop(PyObject *self, PyObject *args) {
921 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
922 nassertr(wrap,
nullptr);
923 if (wrap->_getitem_func ==
nullptr || wrap->_setitem_func ==
nullptr) {
924 return Dtool_Raise_TypeError(
"property does not support pop()");
927 Py_ssize_t size = PyTuple_GET_SIZE(args);
928 if (size != 1 && size != 2) {
929 return PyErr_Format(PyExc_TypeError,
"%s.pop() takes 1 or 2 arguments", wrap->_base._name);
931 PyObject *defvalue = Py_None;
933 defvalue = PyTuple_GET_ITEM(args, 1);
936 PyObject *key = PyTuple_GET_ITEM(args, 0);
937 PyObject *value = wrap->_getitem_func(wrap->_base._self, key);
938 if (value !=
nullptr) {
940 if (wrap->_setitem_func(wrap->_base._self, key,
nullptr) == 0) {
946 }
else if (_PyErr_OCCURRED() == PyExc_KeyError) {
947 PyErr_Restore(
nullptr,
nullptr,
nullptr);
959static PyObject *Dtool_MutableMappingWrapper_popitem(PyObject *self, PyObject *) {
960 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
961 nassertr(wrap,
nullptr);
962 if (wrap->_getitem_func ==
nullptr || wrap->_setitem_func ==
nullptr ||
963 wrap->_keys._len_func ==
nullptr || wrap->_keys._getitem_func ==
nullptr) {
964 return Dtool_Raise_TypeError(
"property does not support popitem()");
967 Py_ssize_t length = wrap->_keys._len_func(wrap->_base._self);
969 return PyErr_Format(PyExc_KeyError,
"%s is empty", wrap->_base._name);
972 PyObject *key = wrap->_keys._getitem_func(wrap->_base._self, length - 1);
973 if (key !=
nullptr) {
974 PyObject *value = wrap->_getitem_func(wrap->_base._self, key);
975 if (value !=
nullptr) {
977 if (wrap->_setitem_func(wrap->_base._self, key,
nullptr) == 0) {
978 PyObject *item = PyTuple_New(2);
979 PyTuple_SET_ITEM(item, 0, key);
980 PyTuple_SET_ITEM(item, 1, value);
993static PyObject *Dtool_MutableMappingWrapper_clear(PyObject *self, PyObject *) {
994 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
995 nassertr(wrap,
nullptr);
996 Py_ssize_t index = 0;
997 if (wrap->_keys._len_func !=
nullptr && wrap->_keys._getitem_func !=
nullptr &&
998 wrap->_setitem_func !=
nullptr) {
999 index = wrap->_keys._len_func(wrap->_base._self);
1001 return Dtool_Raise_TypeError(
"property does not support clear()");
1008 PyObject *key = wrap->_keys._getitem_func(wrap->_base._self, index);
1009 if (key !=
nullptr) {
1010 int result = wrap->_setitem_func(wrap->_base._self, key,
nullptr);
1026static PyObject *Dtool_MutableMappingWrapper_setdefault(PyObject *self, PyObject *args) {
1027 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
1028 nassertr(wrap,
nullptr);
1030 if (wrap->_getitem_func ==
nullptr || wrap->_setitem_func ==
nullptr) {
1031 return Dtool_Raise_TypeError(
"property does not support setdefault()");
1034 Py_ssize_t size = PyTuple_GET_SIZE(args);
1035 if (size != 1 && size != 2) {
1036 return PyErr_Format(PyExc_TypeError,
"%s.setdefault() takes 1 or 2 arguments", wrap->_base._name);
1038 PyObject *defvalue = Py_None;
1040 defvalue = PyTuple_GET_ITEM(args, 1);
1042 PyObject *key = PyTuple_GET_ITEM(args, 0);
1043 PyObject *value = wrap->_getitem_func(wrap->_base._self, key);
1044 if (value !=
nullptr) {
1046 }
else if (_PyErr_OCCURRED() == PyExc_KeyError) {
1047 PyErr_Restore(
nullptr,
nullptr,
nullptr);
1048 if (wrap->_setitem_func(wrap->_base._self, key, defvalue) == 0) {
1049 Py_INCREF(defvalue);
1060static PyObject *Dtool_MutableMappingWrapper_update(PyObject *self, PyObject *args, PyObject *kwargs) {
1061 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)self;
1062 nassertr(wrap,
nullptr);
1064 if (wrap->_getitem_func ==
nullptr || wrap->_setitem_func ==
nullptr) {
1065 return Dtool_Raise_TypeError(
"property does not support update()");
1070 switch (PyTuple_GET_SIZE(args)) {
1072 if (kwargs ==
nullptr) {
1080 if (PyDict_Check(PyTuple_GET_ITEM(args, 0)) && (kwargs ==
nullptr || Py_SIZE(kwargs) == 0)) {
1081 dict = PyTuple_GET_ITEM(args, 0);
1086 return PyErr_Format(PyExc_TypeError,
"%s.update() takes either a dict argument or keyword arguments", wrap->_base._name);
1089 PyObject *key, *value;
1091 while (PyDict_Next(dict, &pos, &key, &value)) {
1092 if (wrap->_setitem_func(wrap->_base._self, key, value) != 0) {
1103static PyObject *Dtool_GeneratorWrapper_iternext(PyObject *self) {
1104 Dtool_GeneratorWrapper *wrap = (Dtool_GeneratorWrapper *)self;
1105 nassertr(wrap,
nullptr);
1106 nassertr(wrap->_iternext_func,
nullptr);
1107 return wrap->_iternext_func(wrap->_base._self);
1115Dtool_StaticProperty_dealloc(PyDescrObject *descr) {
1116#if PY_VERSION_HEX >= 0x03080000
1117 PyObject_GC_UnTrack(descr);
1119 _PyObject_GC_UNTRACK(descr);
1121 Py_XDECREF(descr->d_type);
1122 Py_XDECREF(descr->d_name);
1126 PyObject_GC_Del(descr);
1130Dtool_StaticProperty_repr(PyDescrObject *descr,
const char *format) {
1131#if PY_MAJOR_VERSION >= 3
1132 return PyUnicode_FromFormat(
"<attribute '%s' of '%s'>",
1133 PyUnicode_AsUTF8(descr->d_name),
1134 descr->d_type->tp_name);
1136 return PyString_FromFormat(
"<attribute '%s' of '%s'>",
1137 PyString_AS_STRING(descr->d_name),
1138 descr->d_type->tp_name);
1143Dtool_StaticProperty_traverse(PyObject *self, visitproc visit,
void *arg) {
1144 PyDescrObject *descr = (PyDescrObject *)self;
1145 Py_VISIT(descr->d_type);
1150Dtool_StaticProperty_get(PyGetSetDescrObject *descr, PyObject *obj, PyObject *type) {
1151 if (descr->d_getset->get !=
nullptr) {
1152 return descr->d_getset->get(obj, descr->d_getset->closure);
1154 return PyErr_Format(PyExc_AttributeError,
1155 "attribute '%s' of type '%.100s' is not readable",
1156#
if PY_MAJOR_VERSION >= 3
1157 PyUnicode_AsUTF8(((PyDescrObject *)descr)->d_name),
1159 PyString_AS_STRING(((PyDescrObject *)descr)->d_name),
1161 ((PyDescrObject *)descr)->d_type->tp_name);
1166Dtool_StaticProperty_set(PyGetSetDescrObject *descr, PyObject *obj, PyObject *value) {
1167 if (descr->d_getset->set !=
nullptr) {
1168 return descr->d_getset->set(obj, value, descr->d_getset->closure);
1170 PyErr_Format(PyExc_AttributeError,
1171 "attribute '%s' of type '%.100s' is not writable",
1172#
if PY_MAJOR_VERSION >= 3
1173 PyUnicode_AsUTF8(((PyDescrObject *)descr)->d_name),
1175 PyString_AS_STRING(((PyDescrObject *)descr)->d_name),
1177 ((PyDescrObject *)descr)->d_type->tp_name);
1185Dtool_SequenceWrapper *Dtool_NewSequenceWrapper(PyObject *self,
const char *name) {
1186 Dtool_SequenceWrapper *wrap = (Dtool_SequenceWrapper *)PyObject_MALLOC(
sizeof(Dtool_SequenceWrapper));
1187 if (wrap ==
nullptr) {
1188 return (Dtool_SequenceWrapper *)PyErr_NoMemory();
1191 static PySequenceMethods seq_methods = {
1192 Dtool_SequenceWrapper_length,
1195 Dtool_SequenceWrapper_getitem,
1199 Dtool_SequenceWrapper_contains,
1204 static PyMethodDef methods[] = {
1205 {
"index", &Dtool_SequenceWrapper_index, METH_O,
nullptr},
1206 {
"count", &Dtool_SequenceWrapper_count, METH_O,
nullptr},
1207 {
nullptr,
nullptr, 0,
nullptr}
1210 static PyTypeObject wrapper_type = {
1211 PyVarObject_HEAD_INIT(
nullptr, 0)
1213 sizeof(Dtool_SequenceWrapper),
1215 Dtool_WrapperBase_dealloc,
1220 Dtool_SequenceWrapper_repr,
1227 PyObject_GenericGetAttr,
1228 PyObject_GenericSetAttr,
1230 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
1247 PyType_GenericAlloc,
1258#
if PY_VERSION_HEX >= 0x03040000
1261#
if PY_VERSION_HEX >= 0x03080000
1266 static bool registered =
false;
1270 if (PyType_Ready(&wrapper_type) < 0) {
1275 _register_collection((PyTypeObject *)&wrapper_type,
"Sequence");
1278 (void)PyObject_INIT(wrap, &wrapper_type);
1280 wrap->_base._self = self;
1281 wrap->_base._name = name;
1282 wrap->_len_func =
nullptr;
1283 wrap->_getitem_func =
nullptr;
1290Dtool_MutableSequenceWrapper *Dtool_NewMutableSequenceWrapper(PyObject *self,
const char *name) {
1291 Dtool_MutableSequenceWrapper *wrap = (Dtool_MutableSequenceWrapper *)PyObject_MALLOC(
sizeof(Dtool_MutableSequenceWrapper));
1292 if (wrap ==
nullptr) {
1293 return (Dtool_MutableSequenceWrapper *)PyErr_NoMemory();
1296 static PySequenceMethods seq_methods = {
1297 Dtool_SequenceWrapper_length,
1300 Dtool_SequenceWrapper_getitem,
1302 Dtool_MutableSequenceWrapper_setitem,
1304 Dtool_SequenceWrapper_contains,
1305 Dtool_MutableSequenceWrapper_extend,
1309 static PyMethodDef methods[] = {
1310 {
"index", &Dtool_SequenceWrapper_index, METH_O,
nullptr},
1311 {
"count", &Dtool_SequenceWrapper_count, METH_O,
nullptr},
1312 {
"clear", &Dtool_MutableSequenceWrapper_clear, METH_NOARGS,
nullptr},
1313 {
"pop", &Dtool_MutableSequenceWrapper_pop, METH_VARARGS,
nullptr},
1314 {
"remove", &Dtool_MutableSequenceWrapper_remove, METH_O,
nullptr},
1315 {
"append", &Dtool_MutableSequenceWrapper_append, METH_O,
nullptr},
1316 {
"insert", &Dtool_MutableSequenceWrapper_insert, METH_VARARGS,
nullptr},
1317 {
"extend", &Dtool_MutableSequenceWrapper_extend, METH_O,
nullptr},
1318 {
nullptr,
nullptr, 0,
nullptr}
1321 static PyTypeObject wrapper_type = {
1322 PyVarObject_HEAD_INIT(
nullptr, 0)
1324 sizeof(Dtool_MutableSequenceWrapper),
1326 Dtool_WrapperBase_dealloc,
1331 Dtool_SequenceWrapper_repr,
1338 PyObject_GenericGetAttr,
1339 PyObject_GenericSetAttr,
1341 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
1358 PyType_GenericAlloc,
1369#
if PY_VERSION_HEX >= 0x03040000
1372#
if PY_VERSION_HEX >= 0x03080000
1377 static bool registered =
false;
1381 if (PyType_Ready(&wrapper_type) < 0) {
1386 _register_collection((PyTypeObject *)&wrapper_type,
"MutableSequence");
1389 (void)PyObject_INIT(wrap, &wrapper_type);
1391 wrap->_base._self = self;
1392 wrap->_base._name = name;
1393 wrap->_len_func =
nullptr;
1394 wrap->_getitem_func =
nullptr;
1395 wrap->_setitem_func =
nullptr;
1396 wrap->_insert_func =
nullptr;
1403Dtool_MappingWrapper *Dtool_NewMappingWrapper(PyObject *self,
const char *name) {
1404 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)PyObject_MALLOC(
sizeof(Dtool_MappingWrapper));
1405 if (wrap ==
nullptr) {
1406 return (Dtool_MappingWrapper *)PyErr_NoMemory();
1409 static PySequenceMethods seq_methods = {
1410 Dtool_SequenceWrapper_length,
1417 Dtool_MappingWrapper_contains,
1422 static PyMappingMethods map_methods = {
1423 Dtool_SequenceWrapper_length,
1424 Dtool_MappingWrapper_getitem,
1428 static PyMethodDef methods[] = {
1429 {
"get", &Dtool_MappingWrapper_get, METH_VARARGS,
nullptr},
1430 {
"keys", &Dtool_MappingWrapper_keys, METH_NOARGS,
nullptr},
1431 {
"values", &Dtool_MappingWrapper_values, METH_NOARGS,
nullptr},
1432 {
"items", &Dtool_MappingWrapper_items, METH_NOARGS,
nullptr},
1433 {
nullptr,
nullptr, 0,
nullptr}
1436 static PyTypeObject wrapper_type = {
1437 PyVarObject_HEAD_INIT(
nullptr, 0)
1439 sizeof(Dtool_MappingWrapper),
1441 Dtool_WrapperBase_dealloc,
1446 Dtool_WrapperBase_repr,
1453 PyObject_GenericGetAttr,
1454 PyObject_GenericSetAttr,
1456 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
1462 Dtool_MappingWrapper_iter,
1473 PyType_GenericAlloc,
1484#
if PY_VERSION_HEX >= 0x03040000
1487#
if PY_VERSION_HEX >= 0x03080000
1492 static bool registered =
false;
1496 if (PyType_Ready(&wrapper_type) < 0) {
1501 _register_collection((PyTypeObject *)&wrapper_type,
"Mapping");
1504 (void)PyObject_INIT(wrap, &wrapper_type);
1506 wrap->_base._self = self;
1507 wrap->_base._name = name;
1508 wrap->_keys._len_func =
nullptr;
1509 wrap->_keys._getitem_func =
nullptr;
1510 wrap->_getitem_func =
nullptr;
1511 wrap->_setitem_func =
nullptr;
1518Dtool_MappingWrapper *Dtool_NewMutableMappingWrapper(PyObject *self,
const char *name) {
1519 Dtool_MappingWrapper *wrap = (Dtool_MappingWrapper *)PyObject_MALLOC(
sizeof(Dtool_MappingWrapper));
1520 if (wrap ==
nullptr) {
1521 return (Dtool_MappingWrapper *)PyErr_NoMemory();
1524 static PySequenceMethods seq_methods = {
1525 Dtool_SequenceWrapper_length,
1532 Dtool_MappingWrapper_contains,
1537 static PyMappingMethods map_methods = {
1538 Dtool_SequenceWrapper_length,
1539 Dtool_MappingWrapper_getitem,
1540 Dtool_MutableMappingWrapper_setitem,
1543 static PyMethodDef methods[] = {
1544 {
"get", &Dtool_MappingWrapper_get, METH_VARARGS,
nullptr},
1545 {
"pop", &Dtool_MutableMappingWrapper_pop, METH_VARARGS,
nullptr},
1546 {
"popitem", &Dtool_MutableMappingWrapper_popitem, METH_NOARGS,
nullptr},
1547 {
"clear", &Dtool_MutableMappingWrapper_clear, METH_VARARGS,
nullptr},
1548 {
"setdefault", &Dtool_MutableMappingWrapper_setdefault, METH_VARARGS,
nullptr},
1549 {
"update", (PyCFunction) &Dtool_MutableMappingWrapper_update, METH_VARARGS | METH_KEYWORDS,
nullptr},
1550 {
"keys", &Dtool_MappingWrapper_keys, METH_NOARGS,
nullptr},
1551 {
"values", &Dtool_MappingWrapper_values, METH_NOARGS,
nullptr},
1552 {
"items", &Dtool_MappingWrapper_items, METH_NOARGS,
nullptr},
1553 {
nullptr,
nullptr, 0,
nullptr}
1556 static PyTypeObject wrapper_type = {
1557 PyVarObject_HEAD_INIT(
nullptr, 0)
1559 sizeof(Dtool_MappingWrapper),
1561 Dtool_WrapperBase_dealloc,
1566 Dtool_WrapperBase_repr,
1573 PyObject_GenericGetAttr,
1574 PyObject_GenericSetAttr,
1576 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
1582 Dtool_MappingWrapper_iter,
1593 PyType_GenericAlloc,
1604#
if PY_VERSION_HEX >= 0x03040000
1607#
if PY_VERSION_HEX >= 0x03080000
1612 static bool registered =
false;
1616 if (PyType_Ready(&wrapper_type) < 0) {
1621 _register_collection((PyTypeObject *)&wrapper_type,
"MutableMapping");
1624 (void)PyObject_INIT(wrap, &wrapper_type);
1626 wrap->_base._self = self;
1627 wrap->_base._name = name;
1628 wrap->_keys._len_func =
nullptr;
1629 wrap->_keys._getitem_func =
nullptr;
1630 wrap->_getitem_func =
nullptr;
1631 wrap->_setitem_func =
nullptr;
1639Dtool_NewGenerator(PyObject *self, iternextfunc gen_next) {
1640 static PyTypeObject wrapper_type = {
1641 PyVarObject_HEAD_INIT(
nullptr, 0)
1642 "generator wrapper",
1643 sizeof(Dtool_GeneratorWrapper),
1645 Dtool_WrapperBase_dealloc,
1657 PyObject_GenericGetAttr,
1658 PyObject_GenericSetAttr,
1660 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_CHECKTYPES,
1667 Dtool_GeneratorWrapper_iternext,
1677 PyType_GenericAlloc,
1688#
if PY_VERSION_HEX >= 0x03040000
1691#
if PY_VERSION_HEX >= 0x03080000
1696 if (PyType_Ready(&wrapper_type) < 0) {
1700 Dtool_GeneratorWrapper *gen;
1701 gen = (Dtool_GeneratorWrapper *)PyType_GenericAlloc(&wrapper_type, 0);
1702 if (gen !=
nullptr) {
1704 gen->_base._self = self;
1705 gen->_iternext_func = gen_next;
1707 return (PyObject *)gen;
1715Dtool_NewStaticProperty(PyTypeObject *type,
const PyGetSetDef *getset) {
1716 static PyTypeObject wrapper_type = {
1717 PyVarObject_HEAD_INIT(&PyType_Type, 0)
1718 "getset_descriptor",
1719 sizeof(PyGetSetDescrObject),
1721 (destructor)Dtool_StaticProperty_dealloc,
1726 (reprfunc)Dtool_StaticProperty_repr,
1733 PyObject_GenericGetAttr,
1738 Dtool_StaticProperty_traverse,
1749 (descrgetfunc)Dtool_StaticProperty_get,
1750 (descrsetfunc)Dtool_StaticProperty_set,
1764#
if PY_VERSION_HEX >= 0x03040000
1767#
if PY_VERSION_HEX >= 0x03080000
1772 if (PyType_Ready(&wrapper_type) < 0) {
1776 PyGetSetDescrObject *descr;
1777 descr = (PyGetSetDescrObject *)PyType_GenericAlloc(&wrapper_type, 0);
1778 if (descr !=
nullptr) {
1780 descr->d_getset = (PyGetSetDef *)getset;
1781#if PY_MAJOR_VERSION >= 3
1782 descr->d_common.d_type = type;
1783 descr->d_common.d_name = PyUnicode_InternFromString(getset->name);
1784#if PY_VERSION_HEX >= 0x03030000
1785 descr->d_common.d_qualname =
nullptr;
1788 descr->d_type = type;
1789 descr->d_name = PyString_InternFromString(getset->name);
1792 return (PyObject *)descr;
PyObject * Dtool_WrapValue(int value)
The following functions wrap an arbitrary C++ value into a PyObject.