diff --git a/Foundation/NSArray.swift b/Foundation/NSArray.swift index d6bcf79cf1..bb2139f141 100644 --- a/Foundation/NSArray.swift +++ b/Foundation/NSArray.swift @@ -309,13 +309,13 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS } } - public func sortedArrayUsingFunction(comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer) -> Int, context: UnsafeMutablePointer) -> [AnyObject] { + public func sortedArrayUsingFunction(@noescape comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer) -> Int, context: UnsafeMutablePointer) -> [AnyObject] { return sortedArrayWithOptions([]) { lhs, rhs in return NSComparisonResult(rawValue: comparator(lhs, rhs, context))! } } - public func sortedArrayUsingFunction(comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer) -> Int, context: UnsafeMutablePointer, hint: NSData?) -> [AnyObject] { + public func sortedArrayUsingFunction(@noescape comparator: @convention(c) (AnyObject, AnyObject, UnsafeMutablePointer) -> Int, context: UnsafeMutablePointer, hint: NSData?) -> [AnyObject] { return sortedArrayWithOptions([]) { lhs, rhs in return NSComparisonResult(rawValue: comparator(lhs, rhs, context))! } @@ -348,13 +348,13 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS } } - public func enumerateObjectsUsingBlock(block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { + public func enumerateObjectsUsingBlock(@noescape block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { self.enumerateObjectsWithOptions([], usingBlock: block) } - public func enumerateObjectsWithOptions(opts: NSEnumerationOptions, usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { + public func enumerateObjectsWithOptions(opts: NSEnumerationOptions, @noescape usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { self.enumerateObjectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(0, count)), options: opts, usingBlock: block) } - public func enumerateObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { + public func enumerateObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, @noescape usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { guard !opts.contains(.Concurrent) else { NSUnimplemented() } @@ -364,13 +364,13 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS } } - public func indexOfObjectPassingTest(predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { + public func indexOfObjectPassingTest(@noescape predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { return indexOfObjectWithOptions([], passingTest: predicate) } - public func indexOfObjectWithOptions(opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { + public func indexOfObjectWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { return indexOfObjectAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(0, count)), options: opts, passingTest: predicate) } - public func indexOfObjectAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { + public func indexOfObjectAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { var result = NSNotFound enumerateObjectsAtIndexes(s, options: opts) { (obj, idx, stop) -> Void in if predicate(obj, idx, stop) { @@ -381,13 +381,13 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS return result } - public func indexesOfObjectsPassingTest(predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { + public func indexesOfObjectsPassingTest(@noescape predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { return indexesOfObjectsWithOptions([], passingTest: predicate) } - public func indexesOfObjectsWithOptions(opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { + public func indexesOfObjectsWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { return indexesOfObjectsAtIndexes(NSIndexSet(indexesInRange: NSMakeRange(0, count)), options: opts, passingTest: predicate) } - public func indexesOfObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { + public func indexesOfObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { let result = NSMutableIndexSet() enumerateObjectsAtIndexes(s, options: opts) { (obj, idx, stop) in if predicate(obj, idx, stop) { @@ -397,7 +397,7 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS return result } - internal func sortedArrayFromRange(range: NSRange, options: NSSortOptions, usingComparator cmptr: NSComparator) -> [AnyObject] { + internal func sortedArrayFromRange(range: NSRange, options: NSSortOptions, @noescape usingComparator cmptr: NSComparator) -> [AnyObject] { let count = self.count if range.length == 0 || count == 0 { return [] @@ -408,15 +408,15 @@ public class NSArray : NSObject, NSCopying, NSMutableCopying, NSSecureCoding, NS } } - public func sortedArrayUsingComparator(cmptr: NSComparator) -> [AnyObject] { + public func sortedArrayUsingComparator(@noescape cmptr: NSComparator) -> [AnyObject] { return sortedArrayFromRange(NSMakeRange(0, count), options: [], usingComparator: cmptr) } - public func sortedArrayWithOptions(opts: NSSortOptions, usingComparator cmptr: NSComparator) -> [AnyObject] { + public func sortedArrayWithOptions(opts: NSSortOptions, @noescape usingComparator cmptr: NSComparator) -> [AnyObject] { 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, @noescape usingComparator cmp: NSComparator) -> Int { NSUnimplemented() } // binary search public convenience init?(contentsOfFile path: String) { NSUnimplemented() } public convenience init?(contentsOfURL url: NSURL) { NSUnimplemented() } diff --git a/Foundation/NSAttributedString.swift b/Foundation/NSAttributedString.swift index 208dc4be2e..b6f278b13a 100644 --- a/Foundation/NSAttributedString.swift +++ b/Foundation/NSAttributedString.swift @@ -46,8 +46,8 @@ public class NSAttributedString : NSObject, NSCopying, NSMutableCopying, NSSecur public init(string str: String, attributes attrs: [String : AnyObject]?) { NSUnimplemented() } public init(attributedString attrStr: NSAttributedString) { NSUnimplemented() } - public func enumerateAttributesInRange(enumerationRange: NSRange, options opts: NSAttributedStringEnumerationOptions, usingBlock block: ([String : AnyObject], NSRange, UnsafeMutablePointer) -> Void) { NSUnimplemented() } - public func enumerateAttribute(attrName: String, inRange enumerationRange: NSRange, options opts: NSAttributedStringEnumerationOptions, usingBlock block: (AnyObject?, NSRange, UnsafeMutablePointer) -> Void) { NSUnimplemented() } + public func enumerateAttributesInRange(enumerationRange: NSRange, options opts: NSAttributedStringEnumerationOptions, @noescape usingBlock block: ([String : AnyObject], NSRange, UnsafeMutablePointer) -> Void) { NSUnimplemented() } + public func enumerateAttribute(attrName: String, inRange enumerationRange: NSRange, options opts: NSAttributedStringEnumerationOptions, @noescape usingBlock block: (AnyObject?, NSRange, UnsafeMutablePointer) -> Void) { NSUnimplemented() } } public struct NSAttributedStringEnumerationOptions : OptionSetType { diff --git a/Foundation/NSCalendar.swift b/Foundation/NSCalendar.swift index 826370bdf8..68b49364f3 100644 --- a/Foundation/NSCalendar.swift +++ b/Foundation/NSCalendar.swift @@ -932,7 +932,7 @@ public class NSCalendar : NSObject, NSCopying, NSSecureCoding { Result dates have an integer number of seconds (as if 0 was specified for the nanoseconds property of the NSDateComponents matching parameter), unless a value was set in the nanoseconds property, in which case the result date will have that number of nanoseconds (or as close as possible with floating point numbers). The enumeration is stopped by setting *stop = YES in the block and return. It is not necessary to set *stop to NO to keep the enumeration going. */ - public func enumerateDatesStartingAfterDate(start: NSDate, matchingComponents comps: NSDateComponents, options opts: NSCalendarOptions, usingBlock block: (NSDate?, Bool, UnsafeMutablePointer) -> Void) { NSUnimplemented() } + public func enumerateDatesStartingAfterDate(start: NSDate, matchingComponents comps: NSDateComponents, options opts: NSCalendarOptions, @noescape usingBlock block: (NSDate?, Bool, UnsafeMutablePointer) -> Void) { NSUnimplemented() } /* This method computes the next date which matches (or most closely matches) a given set of components. diff --git a/Foundation/NSData.swift b/Foundation/NSData.swift index 26caa978b0..bee51ffd6c 100644 --- a/Foundation/NSData.swift +++ b/Foundation/NSData.swift @@ -382,7 +382,7 @@ extension NSData { } } - internal func enumerateByteRangesUsingBlockRethrows(block: (UnsafePointer, NSRange, UnsafeMutablePointer) throws -> Void) throws { + internal func enumerateByteRangesUsingBlockRethrows(@noescape block: (UnsafePointer, NSRange, UnsafeMutablePointer) throws -> Void) throws { var err : ErrorType? = nil self.enumerateByteRangesUsingBlock() { (buf, range, stop) -> Void in do { @@ -396,7 +396,7 @@ extension NSData { } } - public func enumerateByteRangesUsingBlock(block: (UnsafePointer, NSRange, UnsafeMutablePointer) -> Void) { + public func enumerateByteRangesUsingBlock(@noescape block: (UnsafePointer, NSRange, UnsafeMutablePointer) -> Void) { var stop = false withUnsafeMutablePointer(&stop) { stopPointer in block(bytes, NSMakeRange(0, length), stopPointer) diff --git a/Foundation/NSDictionary.swift b/Foundation/NSDictionary.swift index d9520ad108..5a2d8e7d17 100644 --- a/Foundation/NSDictionary.swift +++ b/Foundation/NSDictionary.swift @@ -332,11 +332,11 @@ public class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCodin public func writeToFile(path: String, atomically useAuxiliaryFile: Bool) -> Bool { NSUnimplemented() } public func writeToURL(url: NSURL, atomically: Bool) -> Bool { NSUnimplemented() } // the atomically flag is ignored if url of a type that cannot be written atomically. - public func enumerateKeysAndObjectsUsingBlock(block: (NSObject, AnyObject, UnsafeMutablePointer) -> Void) { + public func enumerateKeysAndObjectsUsingBlock(@noescape block: (NSObject, AnyObject, UnsafeMutablePointer) -> Void) { enumerateKeysAndObjectsWithOptions([], usingBlock: block) } - public func enumerateKeysAndObjectsWithOptions(opts: NSEnumerationOptions, usingBlock block: (NSObject, AnyObject, UnsafeMutablePointer) -> Void) { + public func enumerateKeysAndObjectsWithOptions(opts: NSEnumerationOptions, @noescape usingBlock block: (NSObject, AnyObject, UnsafeMutablePointer) -> Void) { let count = self.count var keys = [AnyObject]() var objects = [AnyObject]() @@ -353,22 +353,22 @@ public class NSDictionary : NSObject, NSCopying, NSMutableCopying, NSSecureCodin } } - public func keysSortedByValueUsingComparator(cmptr: NSComparator) -> [AnyObject] { + public func keysSortedByValueUsingComparator(@noescape cmptr: NSComparator) -> [AnyObject] { return keysSortedByValueWithOptions([], usingComparator: cmptr) } - public func keysSortedByValueWithOptions(opts: NSSortOptions, usingComparator cmptr: NSComparator) -> [AnyObject] { + public func keysSortedByValueWithOptions(opts: NSSortOptions, @noescape usingComparator cmptr: NSComparator) -> [AnyObject] { let sorted = allKeys.sort { lhs, rhs in return cmptr(lhs, rhs) == .OrderedSame } return sorted } - public func keysOfEntriesPassingTest(predicate: (AnyObject, AnyObject, UnsafeMutablePointer) -> Bool) -> Set { + public func keysOfEntriesPassingTest(@noescape predicate: (AnyObject, AnyObject, UnsafeMutablePointer) -> Bool) -> Set { return keysOfEntriesWithOptions([], passingTest: predicate) } - public func keysOfEntriesWithOptions(opts: NSEnumerationOptions, passingTest predicate: (AnyObject, AnyObject, UnsafeMutablePointer) -> Bool) -> Set { + public func keysOfEntriesWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, AnyObject, UnsafeMutablePointer) -> Bool) -> Set { var matching = Set() enumerateKeysAndObjectsWithOptions(opts) { key, value, stop in if predicate(key, value, stop) { diff --git a/Foundation/NSIndexSet.swift b/Foundation/NSIndexSet.swift index a7624160c1..a5fb59c679 100644 --- a/Foundation/NSIndexSet.swift +++ b/Foundation/NSIndexSet.swift @@ -330,7 +330,7 @@ public class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding return false } - internal func _enumerateWithOptions(opts : NSEnumerationOptions, range: NSRange, paramType: P.Type, returnType: R.Type, block: (P, UnsafeMutablePointer) -> R) -> Int? { + internal func _enumerateWithOptions(opts : NSEnumerationOptions, range: NSRange, paramType: P.Type, returnType: R.Type, @noescape block: (P, UnsafeMutablePointer) -> R) -> Int? { guard !opts.contains(.Concurrent) else { NSUnimplemented() } @@ -378,33 +378,33 @@ public class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding return result } - public func enumerateIndexesUsingBlock(block: (Int, UnsafeMutablePointer) -> Void) { + public func enumerateIndexesUsingBlock(@noescape block: (Int, UnsafeMutablePointer) -> Void) { enumerateIndexesWithOptions([], usingBlock: block) } - public func enumerateIndexesWithOptions(opts: NSEnumerationOptions, usingBlock block: (Int, UnsafeMutablePointer) -> Void) { + public func enumerateIndexesWithOptions(opts: NSEnumerationOptions, @noescape usingBlock block: (Int, UnsafeMutablePointer) -> Void) { _enumerateWithOptions(opts, range: NSMakeRange(0, Int.max), paramType: Int.self, returnType: Void.self, block: block) } - public func enumerateIndexesInRange(range: NSRange, options opts: NSEnumerationOptions, usingBlock block: (Int, UnsafeMutablePointer) -> Void) { + public func enumerateIndexesInRange(range: NSRange, options opts: NSEnumerationOptions, @noescape usingBlock block: (Int, UnsafeMutablePointer) -> Void) { _enumerateWithOptions(opts, range: range, paramType: Int.self, returnType: Void.self, block: block) } - public func indexPassingTest(predicate: (Int, UnsafeMutablePointer) -> Bool) -> Int { + public func indexPassingTest(@noescape predicate: (Int, UnsafeMutablePointer) -> Bool) -> Int { return indexWithOptions([], passingTest: predicate) } - public func indexWithOptions(opts: NSEnumerationOptions, passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> Int { + public func indexWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> Int { return _enumerateWithOptions(opts, range: NSMakeRange(0, Int.max), paramType: Int.self, returnType: Bool.self, block: predicate) ?? NSNotFound } - public func indexInRange(range: NSRange, options opts: NSEnumerationOptions, passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> Int { + public func indexInRange(range: NSRange, options opts: NSEnumerationOptions, @noescape passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> Int { return _enumerateWithOptions(opts, range: range, paramType: Int.self, returnType: Bool.self, block: predicate) ?? NSNotFound } - public func indexesPassingTest(predicate: (Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { + public func indexesPassingTest(@noescape predicate: (Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { return indexesInRange(NSMakeRange(0, Int.max), options: [], passingTest: predicate) } - public func indexesWithOptions(opts: NSEnumerationOptions, passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { + public func indexesWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { return indexesInRange(NSMakeRange(0, Int.max), options: opts, passingTest: predicate) } - public func indexesInRange(range: NSRange, options opts: NSEnumerationOptions, passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { + public func indexesInRange(range: NSRange, options opts: NSEnumerationOptions, @noescape passingTest predicate: (Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { let result = NSMutableIndexSet() _enumerateWithOptions(opts, range: range, paramType: Int.self, returnType: Void.self) { idx, stop in if predicate(idx, stop) { @@ -419,13 +419,13 @@ public class NSIndexSet : NSObject, NSCopying, NSMutableCopying, NSSecureCoding If the specified range for enumeration intersects a range of contiguous indexes in the receiver, then the block will be invoked with the intersection of those two ranges. */ - public func enumerateRangesUsingBlock(block: (NSRange, UnsafeMutablePointer) -> Void) { + public func enumerateRangesUsingBlock(@noescape block: (NSRange, UnsafeMutablePointer) -> Void) { enumerateRangesWithOptions([], usingBlock: block) } - public func enumerateRangesWithOptions(opts: NSEnumerationOptions, usingBlock block: (NSRange, UnsafeMutablePointer) -> Void) { + public func enumerateRangesWithOptions(opts: NSEnumerationOptions, @noescape usingBlock block: (NSRange, UnsafeMutablePointer) -> Void) { _enumerateWithOptions(opts, range: NSMakeRange(0, Int.max), paramType: NSRange.self, returnType: Void.self, block: block) } - public func enumerateRangesInRange(range: NSRange, options opts: NSEnumerationOptions, usingBlock block: (NSRange, UnsafeMutablePointer) -> Void) { + public func enumerateRangesInRange(range: NSRange, options opts: NSEnumerationOptions, @noescape usingBlock block: (NSRange, UnsafeMutablePointer) -> Void) { _enumerateWithOptions(opts, range: range, paramType: NSRange.self, returnType: Void.self, block: block) } diff --git a/Foundation/NSOrderedSet.swift b/Foundation/NSOrderedSet.swift index 5f201432da..d0b724e5fa 100644 --- a/Foundation/NSOrderedSet.swift +++ b/Foundation/NSOrderedSet.swift @@ -81,22 +81,22 @@ extension NSOrderedSet { public var array: [AnyObject] { NSUnimplemented() } public var set: Set { NSUnimplemented() } - public func enumerateObjectsUsingBlock(block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { NSUnimplemented() } - public func enumerateObjectsWithOptions(opts: NSEnumerationOptions, usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { NSUnimplemented() } - public func enumerateObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { NSUnimplemented() } + public func enumerateObjectsUsingBlock(@noescape block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { NSUnimplemented() } + public func enumerateObjectsWithOptions(opts: NSEnumerationOptions, @noescape usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { NSUnimplemented() } + public func enumerateObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, @noescape usingBlock block: (AnyObject, Int, UnsafeMutablePointer) -> Void) { NSUnimplemented() } - public func indexOfObjectPassingTest(predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { NSUnimplemented() } - public func indexOfObjectWithOptions(opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { NSUnimplemented() } - public func indexOfObjectAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { NSUnimplemented() } + public func indexOfObjectPassingTest(@noescape predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { NSUnimplemented() } + public func indexOfObjectWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { NSUnimplemented() } + public func indexOfObjectAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> Int { NSUnimplemented() } - public func indexesOfObjectsPassingTest(predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { NSUnimplemented() } - public func indexesOfObjectsWithOptions(opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { NSUnimplemented() } - public func indexesOfObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { NSUnimplemented() } + public func indexesOfObjectsPassingTest(@noescape predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { NSUnimplemented() } + public func indexesOfObjectsWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { NSUnimplemented() } + public func indexesOfObjectsAtIndexes(s: NSIndexSet, options opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, Int, UnsafeMutablePointer) -> Bool) -> NSIndexSet { NSUnimplemented() } - public func indexOfObject(object: AnyObject, inSortedRange range: NSRange, options opts: NSBinarySearchingOptions, usingComparator cmp: NSComparator) -> Int { NSUnimplemented() } // binary search + public func indexOfObject(object: AnyObject, inSortedRange range: NSRange, options opts: NSBinarySearchingOptions, @noescape usingComparator cmp: NSComparator) -> Int { NSUnimplemented() } // binary search - public func sortedArrayUsingComparator(cmptr: NSComparator) -> [AnyObject] { NSUnimplemented() } - public func sortedArrayWithOptions(opts: NSSortOptions, usingComparator cmptr: NSComparator) -> [AnyObject] { NSUnimplemented() } + public func sortedArrayUsingComparator(@noescape cmptr: NSComparator) -> [AnyObject] { NSUnimplemented() } + public func sortedArrayWithOptions(opts: NSSortOptions, @noescape usingComparator cmptr: NSComparator) -> [AnyObject] { NSUnimplemented() } public func descriptionWithLocale(locale: AnyObject?) -> String { NSUnimplemented() } public func descriptionWithLocale(locale: AnyObject?, indent level: Int) -> String { NSUnimplemented() } diff --git a/Foundation/NSRegularExpression.swift b/Foundation/NSRegularExpression.swift index cdbfb0d896..edc32087d2 100644 --- a/Foundation/NSRegularExpression.swift +++ b/Foundation/NSRegularExpression.swift @@ -77,7 +77,7 @@ extension NSRegularExpression { /* The fundamental matching method on NSRegularExpression is a block iterator. There are several additional convenience methods, for returning all matches at once, the number of matches, the first match, or the range of the first match. Each match is specified by an instance of NSTextCheckingResult (of type NSTextCheckingTypeRegularExpression) in which the overall match range is given by the range property (equivalent to rangeAtIndex:0) and any capture group ranges are given by rangeAtIndex: for indexes from 1 to numberOfCaptureGroups. {NSNotFound, 0} is used if a particular capture group does not participate in the match. */ - public func enumerateMatchesInString(string: String, options: NSMatchingOptions, range: NSRange, usingBlock block: (NSTextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer) -> Void) { NSUnimplemented() } + public func enumerateMatchesInString(string: String, options: NSMatchingOptions, range: NSRange, @noescape usingBlock block: (NSTextCheckingResult?, NSMatchingFlags, UnsafeMutablePointer) -> Void) { NSUnimplemented() } public func matchesInString(string: String, options: NSMatchingOptions, range: NSRange) -> [NSTextCheckingResult] { NSUnimplemented() } public func numberOfMatchesInString(string: String, options: NSMatchingOptions, range: NSRange) -> Int { NSUnimplemented() } diff --git a/Foundation/NSSet.swift b/Foundation/NSSet.swift index 4fae99db8c..047416c3e4 100644 --- a/Foundation/NSSet.swift +++ b/Foundation/NSSet.swift @@ -277,11 +277,11 @@ extension NSSet { return result } - public func enumerateObjectsUsingBlock(block: (AnyObject, UnsafeMutablePointer) -> Void) { + public func enumerateObjectsUsingBlock(@noescape block: (AnyObject, UnsafeMutablePointer) -> Void) { enumerateObjectsWithOptions([], usingBlock: block) } - public func enumerateObjectsWithOptions(opts: NSEnumerationOptions, usingBlock block: (AnyObject, UnsafeMutablePointer) -> Void) { + public func enumerateObjectsWithOptions(opts: NSEnumerationOptions, @noescape usingBlock block: (AnyObject, UnsafeMutablePointer) -> Void) { var stop : ObjCBool = false for obj in self { withUnsafeMutablePointer(&stop) { stop in @@ -293,11 +293,11 @@ extension NSSet { } } - public func objectsPassingTest(predicate: (AnyObject, UnsafeMutablePointer) -> Bool) -> Set { + public func objectsPassingTest(@noescape predicate: (AnyObject, UnsafeMutablePointer) -> Bool) -> Set { return objectsWithOptions([], passingTest: predicate) } - public func objectsWithOptions(opts: NSEnumerationOptions, passingTest predicate: (AnyObject, UnsafeMutablePointer) -> Bool) -> Set { + public func objectsWithOptions(opts: NSEnumerationOptions, @noescape passingTest predicate: (AnyObject, UnsafeMutablePointer) -> Bool) -> Set { var result = Set() enumerateObjectsWithOptions(opts) { obj, stopp in if predicate(obj, stopp) { diff --git a/Foundation/NSString.swift b/Foundation/NSString.swift index 1521ca0f85..ef1855344b 100644 --- a/Foundation/NSString.swift +++ b/Foundation/NSString.swift @@ -527,11 +527,11 @@ extension NSString { NSUnimplemented() } - public func enumerateSubstringsInRange(range: NSRange, options opts: NSStringEnumerationOptions, usingBlock block: (String?, NSRange, NSRange, UnsafeMutablePointer) -> Void) { + public func enumerateSubstringsInRange(range: NSRange, options opts: NSStringEnumerationOptions, @noescape usingBlock block: (String?, NSRange, NSRange, UnsafeMutablePointer) -> Void) { NSUnimplemented() } - public func enumerateLinesUsingBlock(block: (String, UnsafeMutablePointer) -> Void) { + public func enumerateLinesUsingBlock(@noescape block: (String, UnsafeMutablePointer) -> Void) { NSUnimplemented() }