How can I maintain a global cache of objects? (or a NSMutableSet w/o retaining contents)

Question

I have an iPhone app which deals with a subset of 25,000 places at any given time.

I'd like to maintain a cache of places so that I know that if one part of my application updates a place, every other part that knows about that place sees the update.

My nieve implementation is create an NSMutableSet to store references to the cached places.

Methods that find new places will first check the cache and return the cached object or if the place isn't in the cache, they will create a new place object and add it to the cache.

The problem is how do I release objects that are no longer needed?

The NSMutableSet will retain the place so the retainCount will never go to zero and dealloc will never be called.

I've thought about overriding release:

static NSMutableSet *cachedPlaces;

@implementation Place 


- (void)release {
  if (self.retainCount == 1) {
    //I'm only being retained by the cache!
    [cachedPlaces removeObject:self];
    [self release];
  }
  [super release];
}

@end

But the apple documentation seems to strongly discourage overriding the release method.

The other way seems to be to garbage collect the cache, maybe when I get a low memory warning:

+ (void)garbageCollectCache {
   NSMutableSet *garbagePlaces = [[NSMutableSet alloc] init];
   Place *place;
   for (place in cachedPlaces) {
     if ([place retainCount] == 1) {
       [garbagePlaces addObject:place];
     }
   }
   for (place in garbagePlaces) {
     [cachedPlaces removeObject:place];
   }
   [garbagePlaces release];
}

But this has blocks adding of objects to the cache and could cause delays in my UI.

Is there a kosher method to handle the release scenario? Is there some other pattern for doing this that I'm not aware of.

(and CoreData is not an option at this point, but I understand that it handles this).

Thank you,

Answer 1

Use Core Data if you can deploy to iPhoneOS 3.0 or greater, or use SQLite for iPhoneOS 2.x. Either way you'll be able to use a database to store your data, and you'll be able to do queries to get fresh data sets.

Answer 2

On the desktop you can do this with NSPointerSet, on the iPhone it is a bit more difficult.

You can use CoreFoundation to create a non-retaining set if you really want to:

//Default callbacks
CFSetCallBacks callbacks = kCFTypeSetCallBacks;

//Disable retain and release
callbacks.retain = NULL;
callbacks.release = NULL;

cachedPlaces = (NSMutableSet *)CFSetCreateMutable(kCFAllocatorDefault,
                                     0,
                                     &callbacks);

That makes a non-retaining set. Note that you still need to remove the objects from the set when they are released, otherwise you will have stale pointers in your set that will cause you to crash on a deref. So in the objects you are adding to the set you need a dealloc something like this:

- (void)dealloc {
  [cachedPlaces removeObject:self];

  [super dealloc];
}

This is only really suitable for a purely in memory cache of extant references, if you need to also move stuff to and from the disk then CoreData basically takes care of all of this for you.

Answer 3

You could use NSMutableSet as cache and rely on the fact that any object it contains with a retain count of 1 is only owned by the cache. Thus any object with a retain count of 1 should be removed, this is easily done:

NSPredicate* predicate = [NSPredicate predicateWithFormat:@"retainCount > 1"];
[cachedPlaces filterUsingPredicate:predicate];

Do this on a timer, or whenever a a place is added and/or removed if that is not too often. You could also make the predicate a static to avoid generating anew instance every time.