Binary searching through an array with indexOfObject:inSortedRange:options:usingComparator:

This method returns you index of the object in a given array, which can be really useful sometimes. Objects in the array are compared using isEqual: method (which by default compares pointers). That is the reason the method has no chance to know you want it to be compared using some of your custom properties.

For finding specific object in an array by your own property, use can use

• NSArrays method - (NSArray *)filteredArrayUsingPredicate: and a corresponding NSPredicate (there is a lot of questions on SO and tutorials for these)
• own loop comparing any property you want with any value (Car ID of the object with the ID you are searching car by in your case)

It is possible to bludgeon this API into doing what you want, although I do not really advocate this method. If you pass in the key you wish to search for, that will be passed into the comparator along with the element being compared against. However, the order in which these arguments are passed changes so you need to inspect the class of the comparator arguments at runtime to in order to differentiate them and perform your comparison.

- (BWCProductCategory *)categoryForID:(NSNumber *)ID categories:(NSArray *)categories {
    NSRange searchRange = NSMakeRange(0, categories.count);
    NSUInteger index = [categories indexOfObject:ID
                                   inSortedRange:searchRange
                                         options:NSBinarySearchingFirstEqual
                                 usingComparator:^NSComparisonResult(id obj1, id obj2) {
                                     if ([obj1 isKindOfClass:[BWCProductCategory class]]) {
                                         return [[(BWCProductCategory *)obj1 categoryID] compare:obj2];
                                     } else {
                                         return [obj1 compare:[(BWCProductCategory *)obj2 categoryID]];
                                     }
                                 }];

    return (index == NSNotFound) ? nil : categories[index];
}

This does function, however it feels quite awkward, plus I am not confident of the performance impact when performing large searches (although it is surely still less than an O(n) search). Perhaps you could build a nicer method on top of these which hides the kludge factor.

I created an extension to Swift's Array to make Swift usage in this manner very clean.

import Foundation

extension Array where Element: AnyObject {

    public func indexOfObject<T: AnyObject>(obj: T, options opts: NSBinarySearchingOptions, usingComparator cmp: (T, Element) -> NSComparisonResult) -> Int {
        return (self as NSArray).indexOfObject(obj, inSortedRange: NSRange(0..<count), options: opts, usingComparator: { (a: AnyObject, b: AnyObject) -> NSComparisonResult in
            if a === obj {
                return cmp(a as! T, b as! Element)
            } else {
                var result = cmp(b as! T, a as! Element)

                if result == .OrderedDescending {
                    result = .OrderedAscending
                } else if result == .OrderedAscending {
                    result = .OrderedDescending
                }

                return result
            }
        })
    }
}

Here's an example usage:

class ItemWithProperty {
    var property: Int

    init(property: Int) {
        self.property = property
    }
}

let listOfItems = [ItemWithProperty(property: 1),
    ItemWithProperty(property: 20),
    ItemWithProperty(property: 30),
    ItemWithProperty(property: 45),
    ItemWithProperty(property: 45),
    ItemWithProperty(property: 45),
    ItemWithProperty(property: 60),
    ItemWithProperty(property: 77),
]

let indexOf20 = listOfItems.indexOfObject(20, options: .FirstEqual) { number, item in
    number.compare(item.property)
}
// returns 1

let indexOf25 = listOfItems.indexOfObject(25, options: .FirstEqual) { number, item in
    number.compare(item.property)
}
indexOf25 == NSNotFound
// comparison is true, number not found

let indexOfFirst45 = listOfItems.indexOfObject(45, options: .FirstEqual) { number, item in
    number.compare(item.property)
}
// returns 3

let indexOfLast45 = listOfItems.indexOfObject(45, options: .LastEqual) { number, item in
    number.compare(item.property)
}
// returns 5

let indexOf77 = listOfItems.indexOfObject(77, options: .FirstEqual) { number, item in
    number.compare(item.property)
}
// returns 7

The compare: method (which you are using for you binary search comparator) means different things depending on the object. NSString, for example, implements compare as a lexical compare. So, if you have a sorted NSArray of NSString, then what you will get back is the index in the list of a string matching the input string (or NSNotFound if not in the array).

For your object type (MyCarObject) you would implement your definition of compare: to determine the relative ordering of MyCarObjects. Then you could construct a new instance of a MyCarObject, and use this method to determine if an equivalent object (as determined by compare:) is already in the list.

Note that this method does a binary search, so the array must be kept sorted using the same comparator that you are using to search it. You can use NSBinarySearchingInsertionIndex to find the index at which to insert new elements to keep the list sorted.