- (void)someMethod
{
    [self addObserver:self
           forKeyPath:@"view.frame"
              options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionInitial
              context:NULL];
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if ([keyPath isEqualToString:@"view.frame"])
    {
        [self viewDidChangeFrame];
    }
    else
    {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

- (void)removeKVO
{
    [self removeObserver:self forKeyPath:@"view.frame"];
}

When super also expects to receive callbacks for view.frame expected behaviour will quickly break and be hard to track down.

To protect against this the context can be used to distinguish between different classes:

static void *HCViewControllerKVOContext = &HCViewControllerKVOContext;
- (void)someMethod
{
    [self addObserver:self
           forKeyPath:@"view.frame"
              options:NSKeyValueObservingOptionNew | NSKeyValueObservingOptionInitial
              context:HCViewControllerKVOContext];
}

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    if (context == HCViewControllerKVOContext)
    {
        if ([keyPath isEqualToString:@"view.frame"])
        {
            [self viewDidChangeFrame];
        }
    }
    else
    {
        [super observeValueForKeyPath:keyPath ofObject:object change:change context:context];
    }
}

- (void)remoevKVO
{
    [self removeObserver:self forKeyPath:@"view.frame" context:HCViewControllerKVOContext];
}

This will also eliminate calling -[super observeValueForKeyPath:ofObject:change:context:] when the super class doesn't expect it, which will crash.

@interface KPDObject : NSObject
- (void)reduceSize NS_REQUIRES_SUPER;
@end

@interface KPDDataObject : KPDObject
//...
@end

@implementation KPDDataObject
//...
- (void)reduceSize
{
    [self gzipDataIfNeeded];
}
@end

This will result in a warning: KPDDataObject: Method possibly missing a [super reduceSize] call.

Correctly marking methods with this macro is incredibly useful and should greatly reduce the hard to debug bugs introduced by the lack of calling super.

Intentionally not calling super

NS_REQUIRES_SUPER is great to catch mistakes, but there are always cases when circumstances call for breaking the rules. If you are sure that you don't want to call super you can always temporarily ignore the warning for that method, i.e.:

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wobjc-missing-super-calls"
- (void)reduceSize
{
    [self gzipDataIfNeeded];
}
#pragma clang diagnostic pop

This test was conducted in Hammersmith, London on an iPhone 5 using Speedtest.net Mobile Speed Test.

While I was upset that Three took so much longer than they had originally announced, and where generally bad at letting customers know what was going on, now I am happy again.

AOCUDL was inspired by Dustin Bachrach's OCUDL.

The purpose of AOCUDL is to provide a simple way to define custom literals for Objective-C. These are correctly typecast, extensible and flexible.

The source is available on GitHub.

To add this to your project using CocoaPods just add the following to your podfile:

pod 'AOCUDL', '~> 1.0'

Example

NSURLRequest *request = $(NSURLRequest)[@"http://hypercrypt.net"];
NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:request delegate:self];

or simply

NSURLConnection *connection = [[NSURLConnection alloc] initWithRequest:$(NSURLRequest)[@"http://hypercrypt.net"] delegate:self];

This functionality is provided by using Objective-C subscripting and a small macro to glue the whole thing together:

#define $(cls) (cls *)((id)[cls class])

For a custom class to support AOCUDL all that needs to be implemented is one (or both) of the following methods:

+ (instancetype)objectAtIndexedSubscript:(NSUInteger)index;
+ (instancetype)objectForKeyedSubscript:(id)key;

The default implementation on NSObject is to return nil.

Useful Literals

AOCUDL includes a few literals for built-in classes, they broadly match those included by OCUDL. Examples:

• NSMutableURLRequest: $(NSMutableURLRequest)[@"http://hypercrypt.net"] - This creates a GET request
• NSNull: $NSNull or $(NSNull)[any-id-or-NSUInteger]
• NSSet: $(NSSet)[@[object1, object2, object3]]
• NSURLRequest: $(NSURLRequest)[@"http://hypercrypt.net"] - This creates a GET request
• NSURL: $(NSURL)[@"http://hypercrypt.net"]
• NSUUID: $(NSUUID)[@"8DFD5DF3-6D8B-4DC4-B0A2-1F8ED614FC16"]
• UIColor: $(UIColor)[0xff0000]
• UIImage: $(UIImage)[@"testImage"]
• UINib: $(UINib)[@"AOCUDLViewController"]
• UIStoryboard: $(UIStoryboard)[@"Main_iPhone"]

Recently a GitHub project has been published that aims to introduce custom literals to Objective-C. The syntax is simple: $(#FF0000) would return [UIColor redColor] while $(null) could return NSNull. It also allows classes to register their own mapping. Full details can be found on Dustin Bachrach's post about the OCUDL.

Alternative Syntax Suggestion

While OCUDL syntax is simple, it has a few issues. Firstly, there is no way for the compiler to know the returned object's type. While there is a trend towards using instancetype rather than id for return types, this is a step backwards for type checking. It is made worse as the implementation relies on prefixes and suffixes, something that may clash. I would propose an alternative syntax:

$(NSURL)[@"http://apple.com"];
$(NSURLRequest)[@"http://apple.com"];
$(UIColor)[0xff0000];
$(NSSet)[@[@1, @2, @3]];

This can be implemented with the following macro:

#define $(cls) (cls *)((id)[cls class])

To make a class support the syntax, there is no need to register anything with a manager class, the only thing that needs to be implemented is one or both of the following methods:

+ (id)objectAtIndexedSubscript:(NSUInteger)idx;
+ (id)objectForKeyedSubscript:(id)key;

The NSSet example can easily be implemented in the following way:

@implimentation NSSet (AOCUDL)

+ (id)objectForKeyedSubscript:(id)key
{
    return [self setWithArray:key];
}

@end

This uses the same syntax used for the new object subscripting syntax (e.g NSArray or NSDictionary). This also allows the returned object to be cast to the correct class, allowing for warnings and errors to be correctly generated. It also allows for two classes to respond to the same object in different ways (e.g. NSURL and NSURLRequest above).

This adds a context property to UIAlertView to allow an object to be associated with it. The aim is to allow the delegate to perform the appropriate action without having to add a property on the view controller or having to assign arbitrary numbers to the alert view's tag.

1.2 also adds support for Cocoapods subspecs, you can now include just the HCViews that you would like:

pod 'HCViews/HCBlockView', '~> 1.2'
pod 'HCViews/HCChevronView', '~> 1.2'
pod 'HCViews/HCClippingView', '~> 1.2'
pod 'HCViews/UIAlertViewHCContext', '~> 1.2'

or get everything

pod 'HCViews', '~> 1.2'

The full source is available on GitHub

The iPad mini with Retina Display has a 1.3GHz A7 CPU, slightly slower than the iPad Air's 1.4GHz chip. Both iPads have 1GB of memory.

Compared to the original iPad mini the new iPad mini performs amazingly.

Benchmark Results

System Information

Integer Performance

Floating Point Performance

Memory Performance

You can find a copy of the full results on Geekbench's website.

To deal with this, HCObjectSwitch adds a simple syntax that is very similar to the native switch statement. In order to avoid clashing with the native syntax, all keywords start with a capital letter.

HCObjectSwitch

Overview

A simple way to implement object based switch-like statements in Objective-C using blocks. Any object that conforms to NSCopying can be used to switched on.

Example

id inVariable = /* ... */;
__block id outVariable;

Switch (segue.identifier)
{
    Case (@"EmbedLoginViewController")
    {
        self.loginViewController = segue.destinationViewController;
        outVariable = @"Embed";

        FallThroughToDefault();
    }, // each case statement needs to be wrapped in parenthesees and terminated with a comma

    Case (@"ShowSettingsViewController")
    {
        HCSettingsViewController *settingsViewController = segue.destinationViewController;
        settingsViewController.delegate = self;
        settingsViewController.title = inVariable;

        outVariable = @"Show";

        FallThroughToDefault();
    },

    Default
    {
        // The _object_ object is the object that was used in the switch statement.
        // This is available automatically.
        NSLog(@"Segue '%@' triggered by: %@", _object_, sender);
    },
}; // The ; is required

Usage

The syntaxt for HCObjectSwitch is very close to the standard switch statement. All keywords start with a capital letter.

• Switch (object) Starts a switch clause on object
• Case (option) Code executed if the object matches option. This is implemented through blocks under the hood, thus when writing to variables in the enclosing scope they need to be __block.
• Default Code executed in the default case
• FallthroughTo(option) Fall through to the option case. Cases can be skipped.
• FallThroughToDefault Fall through to the default case. Cases can be skipped.

Parentheses after the Switch and Case statements are required, as is the comma at the end of the parenthesis.