Implemented various sorting methods for the NSMutableArray class.

Author: sgl0v

Foundation/NSArray.swift

@@ -722,7 +722,6 @@ public class NSMutableArray : NSArray {
             replaceObjectsInRange(NSMakeRange(0, count), withObjectsFromArray: otherArray)
         }
     }
-    public func sortUsingFunction(compare: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>) { NSUnimplemented() }
 
     public func insertObjects(objects: [AnyObject], atIndexes indexes: NSIndexSet) {
         precondition(objects.count == indexes.count)
@@ -752,9 +751,18 @@ public class NSMutableArray : NSArray {
             objectIndex += range.length
         }
     }
-    
-    public func sortUsingComparator(cmptr: NSComparator) { NSUnimplemented() }
-    public func sortWithOptions(opts: NSSortOptions, usingComparator cmptr: NSComparator) { NSUnimplemented() }
+
+    public func sortUsingFunction(compare: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer<Void>) -> Int, context: UnsafeMutablePointer<Void>) {
+        self.setArray(self.sortedArrayUsingFunction(compare, context: context))
+    }
+
+    public func sortUsingComparator(cmptr: NSComparator) {
+        self.sortWithOptions([], usingComparator: cmptr)
+    }
+
+    public func sortWithOptions(opts: NSSortOptions, usingComparator cmptr: NSComparator) {
+        self.setArray(self.sortedArrayWithOptions(opts, usingComparator: cmptr))
+    }
 
     public convenience init?(contentsOfFile path: String) { NSUnimplemented() }
     public convenience init?(contentsOfURL url: NSURL) { NSUnimplemented() }

TestFoundation/TestNSArray.swift

@@ -36,6 +36,8 @@ class TestNSArray : XCTestCase {
             ("test_sortedArrayWithOptionsUsingComparator", test_sortedArrayWithOptionsUsingComparator),
             ("test_arrayReplacement", test_arrayReplacement),
             ("test_arrayReplaceObjectsInRangeFromRange", test_arrayReplaceObjectsInRangeFromRange),
+            ("test_sortUsingFunction", test_sortUsingFunction),
+            ("test_sortUsingComparator", test_sortUsingComparator)
         ]
     }
 
@@ -302,4 +304,48 @@ class TestNSArray : XCTestCase {
         let emptyArray = NSArray().sortedArrayWithOptions([]) { _,_ in .OrderedSame }
         XCTAssertTrue(emptyArray.isEmpty)
     }
+
+    func test_sortUsingFunction() {
+        let inputNumbers = [11, 120, 215, 11, 1, -22, 35, -89, 65]
+        let mutableInput = inputNumbers.bridge().mutableCopy() as! NSMutableArray
+        let expectedNumbers = inputNumbers.sort()
+
+        func compare(left: AnyObject, right:AnyObject,  context: UnsafeMutablePointer<Void>) -> Int {
+            let l = (left as! NSNumber).integerValue
+            let r = (right as! NSNumber).integerValue
+            return l < r ? -1 : (l > r ? 0 : 1)
+        }
+        mutableInput.sortUsingFunction(compare, context: UnsafeMutablePointer<Void>(bitPattern: 0))
+
+        XCTAssertEqual(mutableInput.map { ($0 as! NSNumber).integerValue}, expectedNumbers)
+    }
+
+    func test_sortUsingComparator() {
+        // check behaviour with Array's sort method
+        let inputNumbers = [11, 120, 215, 11, 1, -22, 35, -89, 65]
+        let mutableInput = inputNumbers.bridge().mutableCopy() as! NSMutableArray
+        let expectedNumbers = inputNumbers.sort()
+
+        mutableInput.sortUsingComparator { left, right -> NSComparisonResult in
+            let l = (left as! NSNumber).integerValue
+            let r = (right as! NSNumber).integerValue
+            return l < r ? .OrderedAscending : (l > r ? .OrderedSame : .OrderedDescending)
+        }
+
+        XCTAssertEqual(mutableInput.map { ($0 as! NSNumber).integerValue}, expectedNumbers);
+
+        // check that it works in the way self.sortWithOptions([], usingComparator: cmptr) does
+        let inputStrings = ["this", "is", "a", "test", "of", "sort", "with", "strings"]
+        let mutableStringsInput1 = inputStrings.bridge().mutableCopy() as! NSMutableArray
+        let mutableStringsInput2 = inputStrings.bridge().mutableCopy() as! NSMutableArray
+        let comparator: (AnyObject, AnyObject) -> NSComparisonResult = { left, right -> NSComparisonResult in
+            let l = left as! NSString
+            let r = right as! NSString
+            return l.localizedCaseInsensitiveCompare(r.bridge())
+        }
+        mutableStringsInput1.sortUsingComparator(comparator)
+        mutableStringsInput2.sortWithOptions([], usingComparator: comparator)
+        XCTAssertTrue(mutableStringsInput1.isEqualToArray(mutableStringsInput2.bridge()))
+    }
+
 }