When making a small open source iOS API, how do I account for ARC and non-arc users - iphone

Question

I have seen some libraries use separate branches in their source control. One for ARC one for non-ARC. I dont see this as partical as it requires extra maintaince.
A method I thought was to use the compiler flag: (see this question)
#if __has_feature(objc_arc)
Whenever I need to use retain release etc... That way if the user has it switched on the code will automatically re-factor itself.
Is there a disadvantage of doing this way?
Is there a better way to do it?

Answer 1

While Dave's answer is correct, there is an alternative pattern that avoids having to maintain two memory models in your code.
Namely, compile your code with ARC required and either:
use a static library to distrubute your code; whether that static library is built by a new target in the destination project or you distribute the library itself, ARC can be turned on for the target that builds the library.
turn on ARC for just the files when added to whatever target in the target project. ARC can be turned on per-file.
In any case, mixing ARC and non-ARC code at the per-file level is fully supported and works just fine (as demonstrated by the fact that the system frameworks are almost entirely compiled non-ARC, but work fine from ARC).

Answer 2

That's pretty much how I do it. I also have some macros so that my code stays relatively "clean":
#if __has_feature(objc_arc)
#define DD_HAS_ARC 1
#define DD_RETAIN(_o) (_o)
#define DD_RELEASE(_o)
#define DD_AUTORELEASE(_o) (_o)
#else
#define DD_HAS_ARC 0
#define DD_RETAIN(_o) [(_o) retain]
#define DD_RELEASE(_o) [(_o) release]
#define DD_AUTORELEASE(_o) [(_o) autorelease]
#endif
With these, I can do stuff like:
return DD_AUTORELEASE(DD_RETAIN(_myIvar));
Or:
DD_RELEASE(_myIvar);
_myIvar = DD_RETAIN(newObject);
Or:
- (void)dealloc {
DD_RELEASE(_myIvar);
#if !DD_HAS_ARC
[super dealloc];
#endif
}
And then the macro expands into the correct code depending on whether I'm compiling with ARC or not.

Answer 3

If you are developing a static (compiled) library then you can use what ever approach you want.
Most of the difference is at compile time.
Meaning that the generated output should be the same (if you manage the memory properly in the non-ARC version).
Once you compile it, any project may use it without concerning whether your library was developed with or without ARC.
Bottom line, you may develop an ARC based library and use it in non-ARC project (and visa versa) with no problem.