Merge pull request #118 from HeMet/master

Implement NSArray.indexOfObject(inSortedRange:options:usingComparator)

Author: phausler

Foundation/NSArray.swift

@@ -411,7 +411,70 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS
         return sortedArrayFromRange(NSMakeRange(0, count), options: opts, usingComparator: cmptr)
     }
 
-    public func indexOfObject(obj: AnyObject, inSortedRange r: NSRange, options opts: NSBinarySearchingOptions, usingComparator cmp: NSComparator) -> Int { NSUnimplemented() } // binary search
+    public func indexOfObject(obj: AnyObject, inSortedRange r: NSRange, options opts: NSBinarySearchingOptions, usingComparator cmp: NSComparator) -> Int {
+        guard (r.location + r.length) <= count else {
+            NSInvalidArgument("range \(r) extends beyond bounds [0 .. \(count - 1)]")
+        }
+        
+        if opts.contains(.FirstEqual) && opts.contains(.LastEqual) {
+            NSInvalidArgument("both NSBinarySearching.FirstEqual and NSBinarySearching.LastEqual options cannot be specified")
+        }
+        
+        let firstEqual = opts.contains(.FirstEqual)
+        let lastEqual = opts.contains(.LastEqual)
+        let anyEqual = !(firstEqual || lastEqual)
+        
+        var result = NSNotFound
+        var indexOfLeastGreaterThanObj = NSNotFound
+        var start = r.location
+        var end = r.location + r.length - 1
+        
+        loop: while start <= end {
+            let middle = start + (end - start) / 2
+            let item = objectAtIndex(middle)
+            
+            switch cmp(item, obj) {
+                
+            case .OrderedSame where anyEqual:
+                result = middle
+                break loop
+                
+            case .OrderedSame where lastEqual:
+                result = middle
+                fallthrough
+                
+            case .OrderedAscending:
+                start = middle + 1
+                
+            case .OrderedSame where firstEqual:
+                result = middle
+                fallthrough
+                
+            case .OrderedDescending:
+                indexOfLeastGreaterThanObj = middle
+                end = middle - 1
+                
+            default:
+                fatalError("Implementation error.")
+            }
+        }
+        
+        guard opts.contains(.InsertionIndex) && lastEqual else {
+            return result
+        }
+        
+        guard result == NSNotFound else {
+            return result + 1
+        }
+        
+        guard indexOfLeastGreaterThanObj != NSNotFound else {
+            return count
+        }
+        
+        return indexOfLeastGreaterThanObj
+    }
+    
+    
 
     public convenience init?(contentsOfFile path: String) { NSUnimplemented() }
     public convenience init?(contentsOfURL url: NSURL) { NSUnimplemented() }

Foundation/NSObjCRuntime.swift

@@ -80,6 +80,10 @@ public let NSNotFound: Int = Int.max
     fatalError("\(fn) is not yet implemented")
 }
 
+@noreturn func NSInvalidArgument(message: String, method: String = __FUNCTION__) {
+    fatalError("\(method): \(message)")
+}
+
 internal struct _CFInfo {
     // This must match _CFRuntimeBase
     var info: UInt32

TestFoundation/TestNSArray.swift

@@ -27,6 +27,7 @@ class TestNSArray : XCTestCase {
             ("test_enumeration", test_enumeration),
             ("test_sequenceType", test_sequenceType),
             ("test_getObjects", test_getObjects),
+            ("test_binarySearch", test_binarySearch)
         ]
     }
 
@@ -84,4 +85,67 @@ class TestNSArray : XCTestCase {
         XCTAssertEqual(fetched, ["bar", "baz", "foo1"])
     }
 
+    func test_binarySearch() {
+        let array = NSArray(array: [
+            NSNumber(int: 0), NSNumber(int: 1), NSNumber(int: 2), NSNumber(int: 2), NSNumber(int: 3),
+            NSNumber(int: 4), NSNumber(int: 4), NSNumber(int: 6), NSNumber(int: 7), NSNumber(int: 7),
+            NSNumber(int: 7), NSNumber(int: 8), NSNumber(int: 9), NSNumber(int: 9)])
+        
+        // Not sure how to test fatal errors.
+        
+//        NSArray throws NSInvalidArgument if range exceeds bounds of the array.
+//        let rangeOutOfArray = NSRange(location: 5, length: 15)
+//        let _ = array.indexOfObject(NSNumber(integer: 9), inSortedRange: rangeOutOfArray, options: [.InsertionIndex, .FirstEqual], usingComparator: compareIntNSNumber)
+        
+//        NSArray throws NSInvalidArgument if both .FirstEqual and .LastEqaul are specified
+//        let searchForBoth: NSBinarySearchingOptions = [.FirstEqual, .LastEqual]
+//        let _ = objectIndexInArray(array, value: 9, startingFrom: 0, length: 13, options: searchForBoth)
+
+        let notFound = objectIndexInArray(array, value: 11, startingFrom: 0, length: 13)
+        XCTAssertEqual(notFound, NSNotFound, "NSArray return NSNotFound if object is not found.")
+        
+        let notFoundInRange = objectIndexInArray(array, value: 7, startingFrom: 0, length: 5)
+        XCTAssertEqual(notFoundInRange, NSNotFound, "NSArray return NSNotFound if object is not found.")
+        
+        let indexOfAnySeven = objectIndexInArray(array, value: 7, startingFrom: 0, length: 13)
+        XCTAssertTrue(Set([8, 9, 10]).contains(indexOfAnySeven), "If no options provided NSArray returns an arbitrary matching object's index.")
+        
+        let indexOfFirstNine = objectIndexInArray(array, value: 9, startingFrom: 7, length: 6, options: [.FirstEqual])
+        XCTAssertTrue(indexOfFirstNine == 12, "If .FirstEqual is set NSArray returns the lowest index of equal objects.")
+        
+        let indexOfLastTwo = objectIndexInArray(array, value: 2, startingFrom: 1, length: 7, options: [.LastEqual])
+        XCTAssertTrue(indexOfLastTwo == 3, "If .LastEqual is set NSArray returns the highest index of equal objects.")
+        
+        let anyIndexToInsertNine = objectIndexInArray(array, value: 9, startingFrom: 0, length: 13, options: [.InsertionIndex])
+        XCTAssertTrue(Set([12, 13, 14]).contains(anyIndexToInsertNine), "If .InsertionIndex is specified and no other options provided NSArray returns any equal or one larger index than any matching object’s index.")
+        
+        let lowestIndexToInsertTwo = objectIndexInArray(array, value: 2, startingFrom: 0, length: 5, options: [.InsertionIndex, .FirstEqual])
+        XCTAssertTrue(lowestIndexToInsertTwo == 2, "If both .InsertionIndex and .FirstEqual are specified NSArray returns the lowest index of equal objects.")
+        
+        let highestIndexToInsertNine = objectIndexInArray(array, value: 9, startingFrom: 7, length: 6, options: [.InsertionIndex, .LastEqual])
+        XCTAssertTrue(highestIndexToInsertNine == 13, "If both .InsertionIndex and .LastEqual are specified NSArray returns the index of the least greater object...")
+        
+        let indexOfLeastGreaterObjectThanFive = objectIndexInArray(array, value: 5, startingFrom: 0, length: 10, options: [.InsertionIndex, .LastEqual])
+        XCTAssertTrue(indexOfLeastGreaterObjectThanFive == 7, "If both .InsertionIndex and .LastEqual are specified NSArray returns the index of the least greater object...")
+        
+        let endOfArray = objectIndexInArray(array, value: 10, startingFrom: 0, length: 13, options: [.InsertionIndex, .LastEqual])
+        XCTAssertTrue(endOfArray == array.count, "...or the index at the end of the array if the object is larger than all other elements.")
+    }
+    
+    func objectIndexInArray(array: NSArray, value: Int, startingFrom: Int, length: Int, options: NSBinarySearchingOptions = []) -> Int {
+        return array.indexOfObject(NSNumber(integer: value), inSortedRange: NSRange(location: startingFrom, length: length), options: options, usingComparator: compareIntNSNumber)
+    }
+    
+    func compareIntNSNumber(lhs: AnyObject, rhs: AnyObject) -> NSComparisonResult {
+        let lhsInt = (lhs as! NSNumber).integerValue
+        let rhsInt = (rhs as! NSNumber).integerValue
+        if lhsInt == rhsInt {
+            return .OrderedSame
+        }
+        if lhsInt < rhsInt {
+            return .OrderedAscending
+        }
+        
+        return .OrderedDescending
+    }
 }