Question

I have a dictionary that stores an object using a combination of the class name and selector as the key. I’m using the following function in order to calculate the hash:

+(NSString*) getKeyForClass:(Class) clazz andSelector:(SEL) selector {
    return [NSString stringWithFormat:@"%@_%@",NSStringFromClass(clazz), NSStringFromSelector(selector)];
}

While running a profiler i’ve discovered that this function is the bottleneck of the computation. Is there a better (= more efficient) way to create a key from a class and a selector?

Answer 1

A few alternatives.

Keep using a string as a key, but do it faster:

Using a string is a bit more heavyweight than you really need, but it is at least simple.

Using -[NSString stringByAppendingString] would be faster. Parsing format strings is a lot of work.

return [[NSStringFromClass(clazz) stringByAppendingString:@"_"] stringByAppendingString:NSStringFromSelector(selector)];

It may be better to use a single NSMutableString instead of making intermediate strings. Profile it and see.

NSMutableString* result = [NSStringFromClass(clazz) mutableCopy];
[result appendString:@"_"];
[result appendString:NSStringFromSelector(selector)];
return result;

Use a custom object as a key:

You can make a custom object as the key that refers to the class and selector. Implement NSCopying and -isEqual: and -hash on it, so you can use it as a key in a dictionary.

@interface MyKey : NSObject <NSCopying>
{
    Class _clazz;
    SEL _selector;
}

- (id)initWithClass:(Class)clazz andSelector:(SEL)selector;

@end

@implementation MyKey

- (id)initWithClass:(Class)clazz andSelector:(SEL)selector
{
    if ((self = [super init])) {
        _clazz = clazz;
        _selector = selector;
    }
    return self;
}

- (id)copyWithZone:(NSZone*)zone
{
    return self; // this object is immutable, so no need to actually copy it
}

- (BOOL)isEqual:(id)other
{
    if ([other isKindOfClass:[MyKey class]]) {
        MyKey* otherKey = (MyKey*)other;
        return _clazz == otherKey->_clazz && _selector == otherKey->_selector;
    } else {
        return NO;
    }
}

// Hash combining method from http://www.mikeash.com/pyblog/friday-qa-2010-06-18-implementing-equality-and-hashing.html
#define NSUINT_BIT (CHAR_BIT * sizeof(NSUInteger))
#define NSUINTROTATE(val, howmuch) ((((NSUInteger)val) << howmuch) | (((NSUInteger)val) >> (NSUINT_BIT - howmuch)))

- (NSUInteger)hash
{
    return NSUINTROTATE([_clazz hash], NSUINT_BIT / 2) ^ (NSUInteger)_selector;
}

@end

+ (MyKey*)keyForClass:(Class)clazz andSelector:(SEL)selector
{
    return [[MyKey alloc] initWithClass:clazz andSelector:selector];
}

Eliminate the middleman:

If you never need to pull the class and selector out of your key object, then you can just use the hash as computed above, stored in an NSNumber.

// Hash combining method from http://www.mikeash.com/pyblog/friday-qa-2010-06-18-implementing-equality-and-hashing.html
#define NSUINT_BIT (CHAR_BIT * sizeof(NSUInteger))
#define NSUINTROTATE(val, howmuch) ((((NSUInteger)val) << howmuch) | (((NSUInteger)val) >> (NSUINT_BIT - howmuch)))

+ (NSNumber*)keyForClass:(Class)clazz andSelector:(SEL)selector
{
    NSUInteger hash = NSUINTROTATE([clazz hash], NSUINT_BIT / 2) ^ (NSUInteger)selector;
    return [NSNumber numberWithUnsignedInteger:hash];
}