Tewha » objective-c

Blocks to remove redundancy

Steven Fisher — Fri, 29 Jul 2011 15:25:56 +0000

Blocks have many complicated uses, from event-based code to multithreading. But they can also be used for very trivial tasks, such as removing redundant lines from code.

Here’s a common operation for me: Split a list into sublists based on some piece of data changing within a loop. When the loop is over, dump whatever’s left into another sublist.

Without blocks, this looks like this:


- (NSArray *)splitArray: (NSArray *)array
               valueKey: (NSString *)valueKey
               labelKey: (NSString *)labelKey;
{
    id sections = [NSMutableArray array];
    id sectionValue = nil;
    id sectionRecords = [NSMutableArray array];
    
    for (id record in array) {
        id recordValue = [record objectForKey: valueKey];
        if ( ![recordValue isEqual: sectionValue] ) {
            if ( [sectionRecords count] ) {
                id lastRecord = [sectionRecords objectAtIndex: 0];
                id label = [lastRecord objectForKey: labelKey];
                id section = [NSDictionary dictionaryWithObjectsAndKeys:
                              [NSArray arrayWithArray: sectionRecords], @"Records",
                              label, @"Name",
                              nil];
                [sections addObject: section];
                [sectionRecords removeAllObjects];
            }
            sectionValue = recordValue;
        }
        [sectionRecords addObject: record];
    }
    if ( [sectionRecords count] ) {
        id lastRecord = [sectionRecords objectAtIndex: 0];
        id label = [lastRecord objectForKey: labelKey];
        id section = [NSDictionary dictionaryWithObjectsAndKeys:
                      [NSArray arrayWithArray: sectionRecords], @"Records",
                      label, @"Name",
                      nil];
        [sections addObject: section];
        [sectionRecords removeAllObjects];
    }
    
    return [NSArray arrayWithArray: sections];
}

- (NSArray *)splitArray: (NSArray *)array
               valueKey: (NSString *)valueKey
               labelKey: (NSString *)labelKey;
{
    id sections = [NSMutableArray array];
    id sectionValue = nil;
    id sectionRecords = [NSMutableArray array];
    
    for (id record in array) {
        id recordValue = [record objectForKey: valueKey];
        if ( ![recordValue isEqual: sectionValue] ) {
            if ( [sectionRecords count] ) {
                id lastRecord = [sectionRecords objectAtIndex: 0];
                id label = [lastRecord objectForKey: labelKey];
                id section = [NSDictionary dictionaryWithObjectsAndKeys:
                              [NSArray arrayWithArray: sectionRecords], @"Records",
                              label, @"Name",
                              nil];
                [sections addObject: section];
                [sectionRecords removeAllObjects];
            }
            sectionValue = recordValue;
        }
        [sectionRecords addObject: record];
    }
    if ( [sectionRecords count] ) {
        id lastRecord = [sectionRecords objectAtIndex: 0];
        id label = [lastRecord objectForKey: labelKey];
        id section = [NSDictionary dictionaryWithObjectsAndKeys:
                      [NSArray arrayWithArray: sectionRecords], @"Records",
                      label, @"Name",
                      nil];
        [sections addObject: section];
        [sectionRecords removeAllObjects];
    }
    
    return [NSArray arrayWithArray: sections];
}

The redundancy makes this hard to maintain, but I don’t really want to split it off into a different function. That means passing all the parameters in to the second function.

But wait! Can we use blocks to clean this up? Yes, we can! We can define the code we want to execute in a block, then use the block as necessary within the function.

With blocks, the code looks like this:


- (NSArray *)splitArray: (NSArray *)array
               valueKey: (NSString *)valueKey
               labelKey: (NSString *)labelKey;
{
    id sections = [NSMutableArray array];
    id sectionValue = nil;
    id sectionRecords = [NSMutableArray array];
    
    dispatch_block_t split = ^{
        if ( [sectionRecords count] ) {
            id lastRecord = [sectionRecords objectAtIndex: 0];
            id label = [lastRecord objectForKey: labelKey];
            id section = [NSDictionary dictionaryWithObjectsAndKeys:
                          [NSArray arrayWithArray: sectionRecords], @"Records",
                          label, @"Name",
                          nil];
            [sections addObject: section];
            [sectionRecords removeAllObjects];
        }
    };
    
    for (id record in array) {
        id recordValue = [record objectForKey: valueKey];
        if ( ![recordValue isEqual: sectionValue] ) {
            split();
            sectionValue = recordValue;
        }
        [sectionRecords addObject: record];
    }
    split();
    
    return [NSArray arrayWithArray: sections];
}

- (NSArray *)splitArray: (NSArray *)array
               valueKey: (NSString *)valueKey
               labelKey: (NSString *)labelKey;
{
    id sections = [NSMutableArray array];
    id sectionValue = nil;
    id sectionRecords = [NSMutableArray array];
    
    dispatch_block_t split = ^{
        if ( [sectionRecords count] ) {
            id lastRecord = [sectionRecords objectAtIndex: 0];
            id label = [lastRecord objectForKey: labelKey];
            id section = [NSDictionary dictionaryWithObjectsAndKeys:
                          [NSArray arrayWithArray: sectionRecords], @"Records",
                          label, @"Name",
                          nil];
            [sections addObject: section];
            [sectionRecords removeAllObjects];
        }
    };
    
    for (id record in array) {
        id recordValue = [record objectForKey: valueKey];
        if ( ![recordValue isEqual: sectionValue] ) {
            split();
            sectionValue = recordValue;
        }
        [sectionRecords addObject: record];
    }
    split();
    
    return [NSArray arrayWithArray: sections];
}

Since the block by default has read-only access to any variable it wants as long as it’s in scope, there’s no need to pass parameters into the block.

As I said in the introduction, blocks are a lot more powerful than this. See Apple’s Block Programming Topics for more about that. However, they’re a great tool for small problems as well that you shouldn’t overlook.

foo() vs foo(void)

Steven Fisher — Wed, 25 May 2011 22:57:04 +0000

Old content, but I just needed it now: The difference between foo() and foo(void) by Greg Miller.

Hint: Objective-C doesn’t follow the C++ pattern. You probably want foo(void).

Assign, retain, copy pitfalls in Objective-C

Steven Fisher — Wed, 30 Jun 2010 15:11:47 +0000

Cocoa With Love (Matt Gallagher): Assign, retain, copy pitfalls in Objective-C.

Objective-C 2.2 Features

Steven Fisher — Fri, 25 Jun 2010 20:28:11 +0000

Martin Pilkington (Code Collector Pro) on Objective-C 2.2 features. He covers the code reduction features of the new runtime. These are coming to “modern” Apple runtimes, meaning 64-bit Mac and iPhone.

Objective-C 2.0′s dot syntax

Steven Fisher — Sat, 08 Aug 2009 03:16:45 +0000

Chris Hanson on Objective-C 2.0′s dot syntax. When to use it, when to not use it, and what it’s really there for.

Rules to avoid retain cycles

Steven Fisher — Tue, 28 Jul 2009 01:16:56 +0000

Matt Gallagher: Rules to avoid retain cycles

UIView manipulation made easier with a category

Steven Fisher — Mon, 27 Jul 2009 18:47:43 +0000

Michael Fey: UIView setup easier. I’ve done similar; very helpful.

Objective-J

Steven Fisher — Tue, 16 Dec 2008 06:04:50 +0000

On Leaky Abstractions and Objective-J.

WarpedVisions on Objective-C, square 1

Steven Fisher — Sun, 24 Aug 2008 23:57:28 +0000

Bruce over on WarpedVisions writes on entering the world of Objective-C and Cocoa development.

I’m barely past square one, but I found this an interesting title. Of course, what Bruce means is the whole Mac OS X development experience, but it’s interesting that he worded it in the title as learning Objective-C. It’s a simple, concise yet technically inaccurate way to label the knowledge. ((And I’m not intentionally picking on Bruce here. I have said it this way, and probably will again, and he does get it right in the text, as he noted below.))

Objective-C just might be the easiest part of Mac OS X development. The hard part is simply knowing what objects are available in Cocoa, where they are, and how to string them together. Basically, the typical framework problem. Don’t get me wrong, I’m still at the very bottom of the learning curve here!

Objective-C itself is very nice; it’s a truly minimal extension to C. I’m amazed at how it’s still a very complete object-oriented language yet so simple and small, with everything done the simple way.

When I first started with Cocoa, I was thinking of compiling notes together so I could write a short book/essay on “Learning Cocoa for C++ developers,” but as I’ve gone I’ve realized the first chapter should be “Forget everything you know about C++. You think need ___ to do ___? You do in C++, but in Objective-C just use the Cocoa class ___.”