Question

I’m creating a framework for use by a Cocoa Application on 10.6 and later.

The purpose of the framework is to parse a text file.

Obviously, there are errors that could occur, such as file not found, permissions issues, etc.

What is the right way to handle errors within the framework and notify the host application?

My thoughts were:

1. Do nothing and let the host application catch any exceptions.

2. Have the host application register its first responder with the framework, catch any exceptions, convert them into NSError and pass them to the host app’s responder chain.

Do either of those options make sense? Are there other options? What’s the right way to handle this?

I have read the error and exception handling guides, but they don’t cover this situation and only describe error handling within the application itself.

Answer 1

I would say the correct way is to use NSError directly yourself in all methods that can error. I have done this recently with a utility class I created, and it works very well. You then allow the application to decide what do to with the error (crash, log, something else) and the framework doesn’t need to worry.

Here are the private class methods I used to create the error objects, allowing for underlying POSIX errors (errno etc.):

#pragma mark - Private Methods

- (NSError *)error:(NSString *)localizedDescription
              code:(EZipFileError)code
   underlyingError:(NSError *)underlyingError
{
    NSMutableDictionary *errorDetail = [NSMutableDictionary dictionary];
    [errorDetail setValue:localizedDescription forKey:NSLocalizedDescriptionKey];
    if (underlyingError != nil)
    {
        [errorDetail setValue:underlyingError forKey:NSUnderlyingErrorKey];
    }
    return [NSError errorWithDomain:@"MyErrorDomain"
                               code:(NSInteger)code
                           userInfo:errorDetail];
}

- (NSError *)error:(NSString *)localizedDescription
              code:(EZipFileError)code
{
    return [self error:localizedDescription
                  code:code
       underlyingError:nil];
}

- (NSError *)error:(NSString *)localizedDescription
              code:(EZipFileError)code
        posixError:(int)posixError
{
    NSMutableDictionary *underlyingErrorDetail = [NSMutableDictionary dictionary];
    [underlyingErrorDetail setValue:[NSString stringWithUTF8String:strerror(posixError)]
                             forKey:NSLocalizedDescriptionKey];
    NSError *underlyingError = [NSError errorWithDomain:NSPOSIXErrorDomain
                                                    code:posixError
                                                userInfo:underlyingErrorDetail];
    return [self error:localizedDescription
                  code:code
       underlyingError:underlyingError];
}

Which is used as follows:

if (![self isOpen])
{
    if (error != NULL)
    {
        *error = [self error:@"File is not open"
                        code:ErrorNotOpen];
    }
    return nil;
}

Here’s an example that uses the underlying POSIX error version of the method:

filefp = fopen([filename UTF8String], "rb");
if (filefp == NULL)
{
    if (error != NULL)
    {
        *error = [self error:@"Failed to open file"
                        code:ErrorOpenFileFailed
                  posixError:errno];
    }
    return NO;
}