if (![NSKeyedArchiver archiveRootObject:fooBar toFile:pathToFooBar]) {
	/* handle error */
}

I’ve observed that many basic objects end up with an NSCoding implementation similar to this:

- (id)initWithCoder:(NSCoder *)aCoder {
	if (self = [self init]) {
		[self setFoo:[aCoder objectForKey:TPObjectFooKey];
		[self setBar:[aCoder objectForKey:TPObjectBarKey];
		[self setBozo:[aCoder objectForKey:TPObjectBozoKey];
		[self setAh:[aCoder objectForKey:TPObjectAhKey];
		[self setEh:[aCoder objectForKey:TPObjectEhKey];
	}
	return self;
}
- (void)encodeWithCoder:(NSCoder *)aCoder {
	[aCoder encodeObject:[self foo] forKey:TPObjectFooKey];
	[aCoder encodeObject:[self bar] forKey:TPObjectBarKey];
	[aCoder encodeObject:[self bozo] forKey:TPObjectBozoKey];
	[aCoder encodeObject:[self ah] forKey:TPObjectAhKey];
	[aCoder encodeObject:[self eh] forKey:TPObjectEhKey];
}

Well, I don’t know about you, but I personally hate writing the same code over and over again. Not only is it annoying to rewrite nearly identical code for each project, it is tedious to maintain. If you add another property to your class, you must add it to both your initWithCoder:/encodeWithCoder: methods.

The Solution

Like most developers, I’m efficient lazy. Luckily, this repetitious piece of code is generalizable, and thus can be replaced with a helper class. Harnessing the magic of Key-Value Coding and the Objective-C runtime, I wrote an auto-archiver class that handles this common task.

It’s simple in both concept and integration (if your classes are Key-Value Coding compliant. Which they are, of course. Right? Right!?)

If you are using Objective-C 2.0 properties, you simply call +archiveObject:withCoder: in -encodeWithCoder:, and the corresponding +unarchiveObject:withCoder: in -initWithCoder:.

- (id)initWithCoder:(NSCoder *)aCoder {
	if (self = [self init]) {
		[TPAutoArchiver unarchiveObject:self
				      withCoder:aCoder];
	}
	return self;
}
- (void)encodeWithCoder:(NSCoder *)aCoder {
	[TPAutoArchiver archiveObject:self
			    withCoder:aCoder];
}

If the class uses conventional mutator/accessor pairs, there is a slight bit more work involved. Your class should have the following method as well to specify what other keys you would like serialized:

+ (NSArray *)autoArchiverKeysToAdd {
	return [NSArray arrayWithObjects:@"foo", @"bar", nil];
}

And of course, you can also implement +autoArchiverKeysToExclude if there are keys (properties included) you wish to not archive.

How does it work?

When TPAutoArchiver’s +archiveObject:withCoder: method is invoked, the object being archived’s property names are obtained (via class_copyPropertyList()). If the object has other keys it would like archived (or excluded), those keys are added or removed.

Then, the keys are passed to the NSObject method, -dictionaryWithValuesForKeys:, and we get their values, including non-objects (such as ints, floats, etc.).

Those key/value pairs are then archived under a special key that TPAutoArchiver looks for when unarchiving the object (the unarchiving process invokes -setValuesForKeyWithDictionary: on the object being unarchived to set the values)

Download TPAutoArchiver

Alright kids, that’s all for now. Feel free to contact me and send me errata, feedback, hate mail, etc. at the following address:

joshua AT retainCount DOT com

Sample Project

TPAutoArchiver.m+h

Released under the MIT license (which means you can pretty much do whatever you want with it, provided you keep the copyright notice if you redistribute or modify the source)