def __setitem__(self, index, value):
cobj = self._type_.from_param(value)
if ensure_objects(cobj) is not None:
store_reference(self, index, cobj._objects)
address = self._buffer[0]
address += index * sizeof(self._type_)
cobj._copy_to(address)
def __set__(self, obj, value):
fieldtype = self.ctype
cobj = fieldtype.from_param(value)
if ensure_objects(cobj) is not None:
key = keepalive_key(self.num)
store_reference(obj, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = obj._buffer.fieldaddress(self.name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
obj._buffer.__setattr__(self.name, arg)
def __set__(self, obj, value):
fieldtype = self.ctype
cobj = fieldtype.from_param(value)
if ensure_objects(cobj) is not None:
key = keepalive_key(self.num)
store_reference(obj, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = obj._buffer.fieldaddress(self.name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
obj._buffer.__setattr__(self.name, arg)
def __setattr__(self, name, value):
try:
fieldtype = self._fieldtypes[name].ctype
except KeyError:
return _CData.__setattr__(self, name, value)
if ensure_objects(value) is not None:
key = keepalive_key(getattr(self.__class__, name).num)
store_reference(self, key, value._objects)
arg = fieldtype._CData_value(value)
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = self._buffer.fieldaddress(name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
self._buffer.__setattr__(name, arg)
def __setitem__(self, index, value):
if isinstance(index, slice):
self._slice_setitem(index, value)
return
index = self._fix_index(index)
if getattr(value, '_objects', None):
store_reference(self, index, value._objects)
arg = self._type_._CData_value(value)
if not isinstance(self._type_._ffishape, tuple):
self._buffer[index] = arg
# something more sophisticated, cannot set field directly
else:
from ctypes import memmove
dest = self._buffer.itemaddress(index)
memmove(dest, arg, self._type_._ffishape[0])
def __setattr__(self, name, value):
try:
fieldtype = self._fieldtypes[name].ctype
except KeyError:
return _CData.__setattr__(self, name, value)
if ensure_objects(value) is not None:
key = keepalive_key(getattr(self.__class__, name).num)
store_reference(self, key, value._objects)
arg = fieldtype._CData_value(value)
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = self._buffer.fieldaddress(name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
self._buffer.__setattr__(name, arg)
def __setattr__(self, name, value):
try:
fieldtype = self._fieldtypes[name].ctype
except KeyError:
raise AttributeError(name)
if getattr(value, '_objects', None):
key = keepalive_key(getattr(self.__class__, name).offset)
store_reference(self, key, value._objects)
arg = fieldtype._CData_value(value)
if isinstance(fieldtype._ffishape, tuple):
from ctypes import memmove
dest = self._buffer.fieldaddress(name)
memmove(dest, arg._buffer.buffer, fieldtype._ffishape[0])
else:
self._buffer.__setattr__(name, arg)
def __setattr__(self, name, value):
try:
fieldtype = self._fieldtypes[name].ctype
except KeyError:
raise AttributeError(name)
if getattr(value, '_objects', None):
key = keepalive_key(getattr(self.__class__, name).offset)
store_reference(self, key, value._objects)
arg = fieldtype._CData_value(value)
if isinstance(fieldtype._ffishape, tuple):
from ctypes import memmove
dest = self._buffer.fieldaddress(name)
memmove(dest, arg._buffer.buffer, fieldtype._ffishape[0])
else:
self._buffer.__setattr__(name, arg)
def __setitem__(self, index, value):
if isinstance(index, slice):
self._slice_setitem(index, value)
return
index = self._fix_index(index)
if ensure_objects(value) is not None:
store_reference(self, index, value._objects)
arg = self._type_._CData_value(value)
if self._type_._fficompositesize is None:
self._buffer[index] = arg
# something more sophisticated, cannot set field directly
else:
from ctypes import memmove
dest = self._buffer.itemaddress(index)
memmove(dest, arg, self._type_._fficompositesize)
def __setitem__(self, index, value):
if isinstance(index, slice):
self._slice_setitem(index, value)
return
index = self._fix_index(index)
if ensure_objects(value) is not None:
store_reference(self, index, value._objects)
arg = self._type_._CData_value(value)
if self._type_._fficompositesize is None:
self._buffer[index] = arg
# something more sophisticated, cannot set field directly
else:
from ctypes import memmove
dest = self._buffer.itemaddress(index)
memmove(dest, arg, self._type_._fficompositesize)
def __setitem__(self, index, value):
if isinstance(index, slice):
self._slice_setitem(index, value)
return
index = self._fix_index(index)
if getattr(value, '_objects', None):
store_reference(self, index, value._objects)
arg = self._type_._CData_value(value)
if not isinstance(self._type_._ffishape, tuple):
self._buffer[index] = arg
# something more sophisticated, cannot set field directly
else:
from ctypes import memmove
dest = self._buffer.itemaddress(index)
memmove(dest, arg, self._type_._ffishape[0])
def __set__(self, obj, value):
fieldtype = self.ctype
cobj = fieldtype.from_param(value)
key = keepalive_key(self.num)
if issubclass(fieldtype, _Pointer) and isinstance(cobj, Array):
# if our value is an Array we need the whole thing alive
store_reference(obj, key, cobj)
elif ensure_objects(cobj) is not None:
store_reference(obj, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = obj._buffer.fieldaddress(self.name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
obj._buffer.__setattr__(self.name, arg)
def __setattr__(self, name, value):
try:
fieldtype = self._fieldtypes[name].ctype
except KeyError:
raise AttributeError(name)
if ensure_objects(value) is not None:
key = keepalive_key(getattr(self.__class__, name).num)
store_reference(self, key, value._objects)
arg = fieldtype._CData_value(value)
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = self._buffer.buffer
memmove(dest, arg, fieldtype._fficompositesize)
else:
buf = self._ffiarrays[name].fromaddress(self._buffer.buffer, 1)
buf[0] = arg
def __set__(self, obj, value):
fieldtype = self.ctype
cobj = fieldtype.from_param(value)
key = keepalive_key(self.num)
if issubclass(fieldtype, _Pointer) and isinstance(cobj, Array):
# if our value is an Array we need the whole thing alive
store_reference(obj, key, cobj)
elif ensure_objects(cobj) is not None:
store_reference(obj, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = obj._buffer.fieldaddress(self.name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
obj._buffer.__setattr__(self.name, arg)
def __setattr__(self, name, value):
try:
field = self._fieldtypes[name]
except KeyError:
return _CData.__setattr__(self, name, value)
fieldtype = field.ctype
cobj = fieldtype.from_param(value)
if ensure_objects(cobj) is not None:
key = keepalive_key(field.num)
store_reference(self, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = self._buffer.fieldaddress(name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
self._buffer.__setattr__(name, arg)
def __setattr__(self, name, value):
try:
field = self._fieldtypes[name]
except KeyError:
return _CData.__setattr__(self, name, value)
fieldtype = field.ctype
cobj = fieldtype.from_param(value)
if ensure_objects(cobj) is not None:
key = keepalive_key(field.num)
store_reference(self, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = self._buffer.fieldaddress(name)
memmove(dest, arg, fieldtype._fficompositesize)
else:
self._buffer.__setattr__(name, arg)
def __setattr__(self, name, value):
try:
field = self._fieldtypes[name]
except KeyError:
raise AttributeError(name)
fieldtype = field.ctype
cobj = fieldtype.from_param(value)
if ensure_objects(cobj) is not None:
key = keepalive_key(field.num)
store_reference(self, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = self._buffer.buffer
memmove(dest, arg, fieldtype._fficompositesize)
else:
buf = self._ffiarrays[name].fromaddress(self._buffer.buffer, 1)
buf[0] = arg
def __setattr__(self, name, value):
try:
field = self._fieldtypes[name]
except KeyError:
raise AttributeError(name)
fieldtype = field.ctype
cobj = fieldtype.from_param(value)
if ensure_objects(cobj) is not None:
key = keepalive_key(field.num)
store_reference(self, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize is not None:
from ctypes import memmove
dest = self._buffer.buffer
memmove(dest, arg, fieldtype._fficompositesize)
else:
buf = self._ffiarrays[name].fromaddress(self._buffer.buffer, 1)
buf[0] = arg
def __set__(self, obj, value):
if self.inside_anon_field is not None:
setattr(self.inside_anon_field.__get__(obj), self.name, value)
return
fieldtype = self.ctype
cobj = fieldtype.from_param(value)
key = keepalive_key(self.num)
if issubclass(fieldtype, _Pointer) and isinstance(cobj, Array):
# if our value is an Array we need the whole thing alive
store_reference(obj, key, cobj)
elif ensure_objects(cobj) is not None:
store_reference(obj, key, cobj._objects)
arg = cobj._get_buffer_value()
if fieldtype._fficompositesize_ is not None:
from ctypes import memmove
dest = obj._buffer.fieldaddress(self.name)
memmove(dest, arg, fieldtype._fficompositesize_)
elif not isinstance(obj, _CData):
raise (TypeError, 'not a ctype instance')
else:
obj._buffer.__setattr__(self.name, arg)
def __setitem__(self, index, value):
cobj = self._type_.from_param(value)
if ensure_objects(cobj) is not None:
store_reference(self, index, cobj._objects)
self._subarray(index)[0] = cobj._get_buffer_value()
