weak-references

In Clang's Objective-C Automatic Reference Counting we see the following For __weak objects, the lvalue is updated to point to the new pointee, unless the new pointee is an object currently undergoing deallocation, in which case the lvalue is updated to a null pointer. This must execute atomically with respect to other assignments to the object, to reads from the object, and to the final release of the new pointee. In objc-weak.mm wee see the following chunk of code in weak_register_no_lock() : if (deallocating) { if (crashIfDeallocating) { _objc_fatal("Cannot form weak reference to instance (

Here is my code: extern void _objc_autoreleasePoolPrint(); int main(int argc, const char * argv[]) { NSArray __weak *tmp = nil; @autoreleasepool { NSArray __strong *obj = [[NSArray alloc] init]; NSLog(@"obj &: %p", obj); tmp = obj; NSLog(@"tmp &: %p", tmp); _objc_autoreleasePoolPrint(); } NSLog(@"tmp: %@", tmp); // why not (null) ? return 0; } And console output: 2013-05-01 22:14:32.966 SimpleConsoleObjectiveCApplicationWithARC[40660:f07] obj &: 0x7fedf9403110 2013-05-01 22:14:32.969 SimpleConsoleObjectiveCApplicationWithARC[40660:f07] tmp &: 0x7fedf9403110 objc[40660]: ############## objc

I would like to define a protocol which is used in a Viper architecture to establish a connection between a Viper components using a protocol with a weak property but I get the following error message: 'weak' may only be applied to class and class-bound protocol types, not 'Self.ViperViewClass' protocol ViperPresenter: class { associatedtype ViperViewClass weak var view: ViperViewClass! { get set } } Protocols can't currently require properties to be implemented as weak stored properties. Although the weak and unowned keywords are currently allowed on property requirements, they have no effect

I've a problem with WeakReferences in .NET 4.x, I was running tests to make sure some objects were not referenced anymore (using WeakReferences) and I noticed the behavior is not consistent across framework versions: using System; using System.Text; using NUnit.Framework; [TestFixture] public class WeakReferenceTests { [Test] public void TestWeakReferenceIsDisposed() { WeakReference weakRef = new WeakReference(new StringBuilder("Hello")); GC.Collect(); GC.WaitForPendingFinalizers(); GC.WaitForFullGCComplete(); GC.Collect(); var retrievedSb = weakRef.Target as StringBuilder; Assert.That

Testing code that uses WeakReference failed for me using Mono 2.11.3 (SGen) as well as the stable 2.10.8 version. In a simple code like this object obj = new object(); WeakReference wr = new WeakReference(obj); Assert.IsTrue(wr.IsAlive); obj = null; GC.Collect(); Assert.IsFalse(wr.IsAlive); the second assert will fail. Adding GC.WaitForPendingFinalizers doesn't help. Is this a bug in Mono or in my head? Thanks lupus It is not a bug, but an implementation detail where the Mono GC behaves differently from the MS GC. In this case, since you created the object obj in the same stack frame, it

Do I need to check if weak self is nil in blocks? I create weakSelf pointer like: __weak typeof(self) weakSelf = self; and in the beginning of the blocks I do if(!weakSelf){return;} is this unnecessary? or does it depend on whether I coded the rest correctly so that when the self dies, others die too? That check is unnecessary, and is giving you a false sense of security. Here's the problem: __weak typeof(self) weakSelf = self; dispatch_async(dispatch_get_main_queue(), ^{ if (!weakSelf) { return; } // THE LINE OF INTEREST [weakSelf doSomething]; }); At THE LINE OF INTEREST , some other thread

I'm writing a container class in Swift, which works like as java.util.WeakHashMap in Java. My current implementation is here. class WeakRefMap<Key: Hashable, Value: AnyObject> { private var mapping = [Key: WeakBox<Value>]() subscript(key: Key) -> Value? { get { return mapping[key]?.raw } set { if let o = newValue { mapping[key] = WeakBox(o) } else { mapping.removeValueForKey(key) } } } var count: Int { return mapping.count } } class WeakBox<E: AnyObject> { weak var raw: E! init( _ raw: E) { self.raw = raw } } In this implementation, holded objects in the container are weakly-referenced via