Question

I have a class that essentially acts as a light weight wrapper class around another class. It holds that other class as an iVar. I want to be able to expose certain properties (quite a few actually) of the iVar, but to do so I have to write out each property accessor like so:

- (void) setProperty:(Class *)value{
    _iVar.property = value;
}
- (Class *) property{
    return  _iVar.property;
}

Of course, I have to do this for every single property, which is a pain (there are about 30 of them). I would love to be able to synthesize this but I haven’t been able to figure out how.

Is it possible to synthesize?

Also, I can’t subclass….well, I might be able to but it’s really not recommended. The iVar class is really quite heavy (it implements CoreText). I’d rather write out the methods by hand.

Answer 1

Ok, so here’s the solution I found…ended up being pretty simple once you knew what to do. First overwrite ‘- (id) forwardingTargetForSelector:(SEL)aSelector’ and return the iVar:

- (id) forwardingTargetForSelector:(SEL)aSelector{
    return iVar;
}

When the runtime is looking for a method and cannot find one, it will call this method to see if there is another object to forward the message to. Note that this method normally returns nil and if you return nil here, your program will crash (which is the appropriate behavior).

The second part of the problem is to shush the compiler errors/warnings you’ll get when you try to send a message that’s not declared. This is easily done by declaring a category you don’t implement.

@interface Class (iVarClassMethods)
@propoperty (strong) Class *property1;
......more properties
@end

As long as you don’t put in an implementation anywhere, aka @implementation Class (category), the compiler won’t complain (it’ll assume that the implementation is somewhere….).

Now the only drawback I see is if you change any of the properties in the interface of the iVar Class, you need to make sure you update all other classes that use the method described above, otherwise you’ll crash when another class tries to send what is now the wrong method (and the compiler won’t warn you beforehand). However, this can be gotten around. You can declare protocols in a category. So instead you create a separate protocol for the iVar class and move the methods/properties you wish out of the iVar class into the protocol.

@protocol iVarClassProtocol
@propoperty (strong) Class *property1;
......more properties
@end

Add that protocol to the iVar subclass so it has those methods declared through the protocol now.

@interface iVarClass <iVarClassProtocol>
....other methods/properties you don't need forwarded
@end

Finally, simply add the protocol to the category. So instead of the aforementioned category with explicit declarations you’ll have:

@interface Class (iVarClassMethods) <iVarClassProtocol>
@end

Now, if you need to change any of the to-be-fowarded properties/methods, you change them in the protocol. The compiler will then warn you when you try to send the wrong method to the forwarding class.