root/open-source/closures-in-objc/trunk/MyBlock.m

/* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is trying to emulate Smalltalk style Blocks.
*
* The Initial Developer of the Original Code is
* M-Soft, IT-Dienste.
* Portions created by the Initial Developer are Copyright (C) 2004
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*   Martin HŠcker <mhaecker@mac.com>
*
* ***** END LICENSE BLOCK ***** */

#import "MyBlock.h"
#include <string.h>

#define MY_WRONG_RETURN_VALUE_EXCEPTION @"MyWrongReturnValueException"

@implementation MyBlock

#pragma mark -
#pragma mark Private methods

BOOL AreTypeStringsEqual(char *first, char *second) {
    return (0 == strcmp(first, second));
}

- (void) assertReturnType: (char *) aType numberOfArguments: (int) anInt {
    if (AreTypeStringsEqual(aType, returnType)
            && anInt == numberOfArguments) {
        return;
    }
    [NSException raise:MY_WRONG_RETURN_VALUE_EXCEPTION format:@"Wrong return-type or number of arguments, this block returns '%s' and gets %d arguments", returnType, numberOfArguments];
}

unsigned CountNumberOfArguments(char * aString) {
    id arguments = [NSString stringWithCString: aString];
    if ([arguments isEqualTo:@"void"]) {
        return 0;
    }
    return [[arguments componentsSeparatedByString:@","] count];
}

#pragma mark -
#pragma mark Instance creation

+ blockWithFunction: (void *) aFunctionPointer 
         returnType: (char *) aType 
          arguments: (char *)argumentString;
{
    return [[[[self class] alloc] initWithFunction: aFunctionPointer returnType: aType arguments: argumentString] autorelease];
}


- initWithFunction: (void *) aFunctionPointer 
        returnType: (char *) aType 
         arguments: (char *)argumentString;
{
    if (self = [super init]) {
        func = aFunctionPointer;
        returnType = aType;
        numberOfArguments = CountNumberOfArguments(argumentString);
    }
    return self;
}

// TODO consider adding exceptions to @selector(retain) so nobody tries to store them for long
// this seems to collide with my wish to enable exactly this somehow...

#pragma mark -
#pragma mark Evaluating the block

// TODO I need some sort of error checking!
- value; {
    [self assertReturnType: @encode(id) numberOfArguments: 0];
    functionPointer aFunction = (functionPointer) func;
    return aFunction();
}

- value: argument; {
    [self assertReturnType: @encode(id) numberOfArguments: 1];
    unaryFunctionPointer unary = (unaryFunctionPointer) func;
    return unary(argument);
}

- value: firstArgument value: secondArgument; {
    [self assertReturnType: @encode(id) numberOfArguments: 2];
    binaryFunctionPointer binary = (binaryFunctionPointer) func;
    return binary(firstArgument, secondArgument);
}

- (BOOL) test: argument; {
    [self assertReturnType: @encode(BOOL) numberOfArguments: 1];
    testingFunctionPointer function = (testingFunctionPointer) func;
    return function(argument);
}


@end