Question

I’m working on an assignment which involves making an RPN calculator. I am currently using class methods to check whether a string is an operation as below:

+ (NSSet *) noOpOperations {
    return [NSSet setWithObjects:@"π", nil];
}

+ (NSSet *) unaryOperations {
    return [NSSet setWithObjects:@"sin",@"cos",@"log",@"+/-", nil];
}

+ (NSSet *) binaryOperations {
    return [NSSet setWithObjects:@"+",@"-",@"*",@"/", nil];
}
+ (NSSet *) operations {
    /* surely there is a better way - is it possible to save this call and reuse it?  Or what about having the objects register themselves so you can add operations more easily? */
    return [[self noOpOperations] setByAddingObjectsFromSet:
            [[self unaryOperations] setByAddingObjectsFromSet:
             [self binaryOperations]]];
}

+ (BOOL) isOperation:operand {
    return [[self operations] containsObject:operand]; 
}

I believe it would be better to implement a kind of function registry system to allow dynamic adding of operations from another location in the project, but I think it would require a class variable. Is there a better way to do this than how I am doing it now?

Answer 1

My Personal solution for situations like this:

#define INT_OBJ(x) [NSNumber numberWithInt:x]

@implementation MyClass

static NSDictionary *operations;

enum {
    kOperationNoOp = 1,
    kOperationUnaryOp,
    kOperationBinaryOp,
};

+(void) initialize
{
    operations = [NSDictionary dictionaryWithObjectsAndKeys:@"π",   INT_OBJ(kOperationNoOp), 

                                                            // unary operations
                                                            @"sin", INT_OBJ(kOperationUnaryOp), 
                                                            @"cos", INT_OBJ(kOperationUnaryOp), 
                                                            @"log", INT_OBJ(kOperationUnaryOp), 
                                                            @"+/-", INT_OBJ(kOperationUnaryOp), 

                                                            // binary operations
                                                            @"+",   INT_OBJ(kOperationBinaryOp), 
                                                            @"-",   INT_OBJ(kOperationBinaryOp), 
                                                            @"*",   INT_OBJ(kOperationBinaryOp), 
                                                            @"/",   INT_OBJ(kOperationBinaryOp), nil];
}

-(BOOL) isNoOpOperation:(NSString *) arg
{
    return [[operations objectForKey:arg] intValue] == kOperationNoOp;
}

-(BOOL) isUnaryOperation:(NSString *) arg
{
    return [[operations objectForKey:arg] intValue] == kOperationUnaryOp;
}

-(BOOL) isBinaryOperation:(NSString *) arg
{
    return [[operations objectForKey:arg] intValue] == kOperationBinaryOp;
}

-(BOOL) isAnOperation:(NSString *) arg
{
    // if objectForKey: returns nil, intValue will return 0, telling us that the input is not an operation
    return [[operations objectForKey:arg] intValue] != 0;
}

@end

I find it to be very straightforward and easy to extend.