Allow declaring weak properties

changes/210.feature.rst

@@ -0,0 +1 @@
+Added support to declare weak properties on custom Objective-C classes.

rubicon/objc/api.py

@@ -368,26 +368,36 @@ class MySubclass(NSObject):
     the generated setter keeps the stored object retained, and releases it when it is replaced.
 
     In a custom Objective-C protocol, only the metadata for the property is generated.
+
+    If ``weak`` is ``True``, the property will be created as a weak property. When assigning an object to it,
+    the reference count of the object will not be increased. When the object is deallocated, the property
+    value is set to None.
     """
 
-    def __init__(self, vartype=objc_id):
+    def __init__(self, vartype=objc_id, weak=False):
         super().__init__()
 
         self.vartype = ctype_for_type(vartype)
+        self.weak = weak
 
     def _get_property_attributes(self):
         attrs = [
             objc_property_attribute_t(b'T', encoding_for_ctype(self.vartype)),  # Type: vartype
         ]
         if issubclass(self.vartype, objc_id):
-            attrs.append(objc_property_attribute_t(b'&', b''))  # retain
+            reference = b'W' if self.weak else b'&'
+            attrs.append(objc_property_attribute_t(reference, b''))
         return (objc_property_attribute_t * len(attrs))(*attrs)
 
     def class_register(self, class_ptr, attr_name):
-        add_ivar(class_ptr, '_' + attr_name, self.vartype)
+
+        ivar_name = '_' + attr_name
+
+        add_ivar(class_ptr, ivar_name, self.vartype)
 
         def _objc_getter(objc_self, _cmd):
-            value = get_ivar(objc_self, '_' + attr_name)
+            value = get_ivar(objc_self, ivar_name, weak=self.weak)
+
             # ctypes complains when a callback returns a "boxed" primitive type, so we have to manually unbox it.
             # If the data object has a value attribute and is not a structure or union, assume that it is
             # a primitive and unbox it.
@@ -403,12 +413,21 @@ def _objc_setter(objc_self, _cmd, new_value):
             if not isinstance(new_value, self.vartype):
                 # If vartype is a primitive, then new_value may be unboxed. If that is the case, box it manually.
                 new_value = self.vartype(new_value)
-            old_value = get_ivar(objc_self, '_' + attr_name)
-            if issubclass(self.vartype, objc_id) and new_value:
+
+            if issubclass(self.vartype, objc_id) and not self.weak:
+                old_value = get_ivar(objc_self, ivar_name, weak=self.weak)
+
+                if new_value.value == old_value.value:
+                    # old and new value are the same, nothing to do
+                    return
+
+            if not self.weak and issubclass(self.vartype, objc_id) and new_value:
                 # If the new value is a non-null object, retain it.
                 send_message(new_value, 'retain', restype=objc_id, argtypes=[])
-            set_ivar(objc_self, '_' + attr_name, new_value)
-            if issubclass(self.vartype, objc_id) and old_value:
+
+            set_ivar(objc_self, ivar_name, new_value, weak=self.weak)
+
+            if not self.weak and issubclass(self.vartype, objc_id) and old_value:
                 # If the old value is a non-null object, release it.
                 send_message(old_value, 'release', restype=None, argtypes=[])
 
@@ -426,6 +445,19 @@ def _objc_setter(objc_self, _cmd, new_value):
         attrs = self._get_property_attributes()
         libobjc.class_addProperty(class_ptr, ensure_bytes(attr_name), attrs, len(attrs))
 
+    def dealloc_callback(self, objc_self, attr_name):
+
+        ivar_name = '_' + attr_name
+
+        # Clean up ivar.
+        if self.weak:
+            # Clean up weak reference.
+            set_ivar(objc_self, ivar_name, self.vartype(None), weak=True)
+        elif issubclass(self.vartype, objc_id):
+            # If the old value is a non-null object, release it. There is no need to set the actual ivar to nil.
+            old_value = get_ivar(objc_self, ivar_name, weak=self.weak)
+            send_message(old_value, 'release', restype=None, argtypes=[])
+
     def protocol_register(self, proto_ptr, attr_name):
         attrs = self._get_property_attributes()
         libobjc.protocol_addProperty(proto_ptr, ensure_bytes(attr_name), attrs, len(attrs), True, True)
@@ -968,6 +1000,24 @@ def _new_from_class_statement(cls, name, bases, attrs, *, protocols):
             else:
                 class_register(ptr, attr_name)
 
+        # Add cleanup of ivars / properties to dealloc
+
+        old_dealloc = libobjc.class_getMethodImplementation(ptr, SEL("dealloc"))
+
+        def _new_delloc(objc_self, _cmd):
+
+            # Invoke dealloc callback of each property.
+            for attr_name, obj in attrs.items():
+                if isinstance(obj, objc_property):
+                    obj.dealloc_callback(objc_self, attr_name)
+
+            # Invoke original dealloc.
+            cfunctype = CFUNCTYPE(None, objc_id, SEL)
+            old_dealloc_callable = cast(old_dealloc, cfunctype)
+            old_dealloc_callable(objc_self, SEL("dealloc"))
+
+        add_method(ptr, "dealloc", _new_delloc, [None, ObjCInstance, SEL], replace=True)
+
         # Register the ObjC class
         libobjc.objc_registerClassPair(ptr)
 

rubicon/objc/runtime.py

@@ -301,7 +301,7 @@ class objc_property_attribute_t(Structure):
 
 # IMP class_replaceMethod(Class cls, SEL name, IMP imp, const char *types)
 libobjc.class_replaceMethod.restype = IMP
-libobjc.class_replaceMethod.argtypes = [Class, SEL, Ivar, c_char_p]
+libobjc.class_replaceMethod.argtypes = [Class, SEL, IMP, c_char_p]
 
 # BOOL class_respondsToSelector(Class cls, SEL sel)
 libobjc.class_respondsToSelector.restype = c_bool
@@ -361,6 +361,10 @@ class objc_property_attribute_t(Structure):
 libobjc.objc_allocateClassPair.restype = Class
 libobjc.objc_allocateClassPair.argtypes = [Class, c_char_p, c_size_t]
 
+# id objc_autoreleaseReturnValue(id value)
+libobjc.objc_autoreleaseReturnValue.restype = objc_id
+libobjc.objc_autoreleaseReturnValue.argtypes = [objc_id]
+
 # Protocol **objc_copyProtocolList(unsigned int *outCount)
 # Returns an array of *outcount pointers followed by NULL terminator.
 # You must free() the array.
@@ -383,6 +387,14 @@ class objc_property_attribute_t(Structure):
 libobjc.objc_getProtocol.restype = objc_id
 libobjc.objc_getProtocol.argtypes = [c_char_p]
 
+# id objc_loadWeakRetained(id *object)
+libobjc.objc_loadWeakRetained.restype = objc_id
+libobjc.objc_loadWeakRetained.argtypes = [c_void_p]
+
+# id objc_storeWeak(id *object, id value)
+libobjc.objc_storeWeak.restype = objc_id
+libobjc.objc_storeWeak.argtypes = [c_void_p, objc_id]
+
 # You should set return and argument types depending on context.
 # id objc_msgSend(id theReceiver, SEL theSelector, ...)
 # id objc_msgSendSuper(struct objc_super *super, SEL op,  ...)
@@ -846,7 +858,7 @@ def send_super(cls, receiver, selector, *args, restype=c_void_p, argtypes=None):
 _keep_alive_imps = []
 
 
-def add_method(cls, selector, method, encoding):
+def add_method(cls, selector, method, encoding, replace=False):
     """Add a new instance method to the given class.
 
     To add a class method, add an instance method to the metaclass.
@@ -856,6 +868,8 @@ def add_method(cls, selector, method, encoding):
     :param method: The method implementation, as a Python callable or a C function address.
     :param encoding: The method's signature (return type and argument types) as a :class:`list`.
         The types of the implicit ``self`` and ``_cmd`` parameters must be included in the signature.
+    :param replace: If the class already implements a method with the given name, replaces the current implementation
+        if ``True``. Raises a :class:`ValueError` error otherwise.
     :return: The ctypes C function pointer object that was created for the method's implementation.
         This return value can be ignored. (In version 0.4.0 and older, callers were required to manually
         keep a reference to this function pointer object to ensure that it isn't garbage-collected.
@@ -874,7 +888,14 @@ def add_method(cls, selector, method, encoding):
 
     cfunctype = CFUNCTYPE(*signature)
     imp = cfunctype(method)
-    libobjc.class_addMethod(cls, selector, cast(imp, IMP), types)
+    if replace:
+        libobjc.class_replaceMethod(cls, selector, cast(imp, IMP), types)
+    else:
+        res = libobjc.class_addMethod(cls, selector, cast(imp, IMP), types)
+
+        if not res:
+            raise ValueError("A method with the name {!r} already exists".format(selector.name))
+
     _keep_alive_imps.append(imp)
     return imp
 
@@ -888,7 +909,7 @@ def add_ivar(cls, name, vartype):
     )
 
 
-def get_ivar(obj, varname):
+def get_ivar(obj, varname, weak=False):
     """Get the value of obj's ivar named varname.
 
     The returned object is a :mod:`ctypes` data object.
@@ -909,14 +930,17 @@ def get_ivar(obj, varname):
     ivar = libobjc.class_getInstanceVariable(libobjc.object_getClass(obj), ensure_bytes(varname))
     vartype = ctype_for_encoding(libobjc.ivar_getTypeEncoding(ivar))
 
-    if isinstance(vartype, objc_id):
+    if weak:
+        value = libobjc.objc_loadWeakRetained(obj.value + libobjc.ivar_getOffset(ivar))
+        return libobjc.objc_autoreleaseReturnValue(value)
+    elif issubclass(vartype, objc_id):
         return cast(libobjc.object_getIvar(obj, ivar), vartype)
     else:
         return vartype.from_address(obj.value + libobjc.ivar_getOffset(ivar))
 
 
-def set_ivar(obj, varname, value):
-    """Set obj's ivar varname to value.
+def set_ivar(obj, varname, value, weak=False):
+    """Set obj's ivar varname to value. If ``weak`` is ``True``, only a weak reference to the value is stored.
 
     value must be a :mod:`ctypes` data object whose type matches that of the ivar.
     """
@@ -940,7 +964,9 @@ def set_ivar(obj, varname, value):
             .format(varname, type(value), sizeof(type(value)), vartype, sizeof(vartype))
         )
 
-    if isinstance(vartype, objc_id):
+    if weak:
+        libobjc.objc_storeWeak(obj.value + libobjc.ivar_getOffset(ivar), value)
+    elif issubclass(vartype, objc_id):
         libobjc.object_setIvar(obj, ivar, value)
     else:
         memmove(obj.value + libobjc.ivar_getOffset(ivar), addressof(value), sizeof(vartype))

tests/test_core.py

@@ -1003,6 +1003,47 @@ class Properties(NSObject):
         self.assertEqual(r.size.width, 56)
         self.assertEqual(r.size.height, 78)
 
+    def test_class_properties_lifecycle_strong(self):
+
+        class StrongProperties(NSObject):
+            object = objc_property(ObjCInstance)
+
+        pool = NSAutoreleasePool.alloc().init()
+
+        properties = StrongProperties.alloc().init()
+
+        obj = NSObject.alloc().init()
+        obj_pointer = obj.ptr.value  # store the object pointer for future use
+
+        properties.object = obj
+
+        del obj
+        del pool
+        gc.collect()
+
+        # assert that the object was retained by the property
+        self.assertEqual(properties.object.ptr.value, obj_pointer)
+
+    def test_class_properties_lifecycle_weak(self):
+
+        class WeakProperties(NSObject):
+            object = objc_property(ObjCInstance, weak=True)
+
+        pool = NSAutoreleasePool.alloc().init()
+
+        properties = WeakProperties.alloc().init()
+
+        obj = NSObject.alloc().init()
+        properties.object = obj
+
+        self.assertIs(properties.object, obj)
+
+        del obj
+        del pool
+        gc.collect()
+
+        self.assertIsNone(properties.object)
+
     def test_class_with_wrapped_methods(self):
         """An ObjCClass can have wrapped methods."""