Merge pull request #3769 from parkera/indexset_optional_find

IndexSet's find family of methods should have optional returns

Author: parkera

stdlib/public/SDK/Foundation/IndexSet.swift

@@ -327,29 +327,29 @@ public struct IndexSet : ReferenceConvertible, Equatable, BidirectionalCollectio
         return _handle.map { _toOptional($0.lastIndex) }
     }
 
-    /// Returns an integer contained in `self` which is greater than `integer`.
-    public func integerGreaterThan(_ integer: Element) -> Element {
-        return _handle.map { $0.indexGreaterThanIndex(integer) }
+    /// Returns an integer contained in `self` which is greater than `integer`, or `nil` if a result could not be found.
+    public func integerGreaterThan(_ integer: Element) -> Element? {
+        return _handle.map { _toOptional($0.indexGreaterThanIndex(integer)) }
     }
 
-    /// Returns an integer contained in `self` which is less than `integer`.
-    public func integerLessThan(_ integer: Element) -> Element {
-        return _handle.map { $0.indexLessThanIndex(integer) }
+    /// Returns an integer contained in `self` which is less than `integer`, or `nil` if a result could not be found.
+    public func integerLessThan(_ integer: Element) -> Element? {
+        return _handle.map { _toOptional($0.indexLessThanIndex(integer)) }
     }
 
-    /// Returns an integer contained in `self` which is greater than or equal to `integer`.
-    public func integerGreaterThanOrEqualTo(_ integer: Element) -> Element {
-        return _handle.map { $0.indexGreaterThanOrEqual(to: integer) }
+    /// Returns an integer contained in `self` which is greater than or equal to `integer`, or `nil` if a result could not be found.
+    public func integerGreaterThanOrEqualTo(_ integer: Element) -> Element? {
+        return _handle.map { _toOptional($0.indexGreaterThanOrEqual(to: integer)) }
     }
 
-    /// Returns an integer contained in `self` which is less than or equal to `integer`.
-    public func integerLessThanOrEqualTo(_ integer: Element) -> Element {
-        return _handle.map { $0.indexLessThanOrEqual(to: integer) }
+    /// Returns an integer contained in `self` which is less than or equal to `integer`, or `nil` if a result could not be found.
+    public func integerLessThanOrEqualTo(_ integer: Element) -> Element? {
+        return _handle.map { _toOptional($0.indexLessThanOrEqual(to: integer)) }
     }
 
     /// Return a `Range<IndexSet.Index>` which can be used to subscript the index set.
     ///
-    /// The resulting range is the range of the intersection of the integers in `range` with the index set.
+    /// The resulting range is the range of the intersection of the integers in `range` with the index set. The resulting range will be `isEmpty` if the intersection is empty.
     ///
     /// - parameter range: The range of integers to include.
     public func indexRange(in range: Range<Element>) -> Range<Index> {
@@ -363,9 +363,14 @@ public struct IndexSet : ReferenceConvertible, Equatable, BidirectionalCollectio
             return i..<i
         }
 
-        let resultFirst = _index(ofInteger: integerGreaterThanOrEqualTo(range.lowerBound))
-        let resultLast = _index(ofInteger: integerLessThanOrEqualTo(range.upperBound - 1))
-        return resultFirst..<index(after: resultLast)
+        if let start = integerGreaterThanOrEqualTo(range.lowerBound), let end = integerLessThanOrEqualTo(range.upperBound - 1) {
+            let resultFirst = _index(ofInteger: start)
+            let resultLast = _index(ofInteger: end)
+            return resultFirst..<index(after: resultLast)
+        } else {
+            let i = _index(ofInteger: 0)
+            return i..<i
+        }
     }
 
     /// Return a `Range<IndexSet.Index>` which can be used to subscript the index set.

test/1_stdlib/TestIndexSet.swift

@@ -79,6 +79,7 @@ class TestIndexSet : TestIndexSetSuper {
 
         r = someIndexes.indexRange(in: 100..<201)
         expectEqual(r.lowerBound, r.upperBound)
+        expectTrue(r.isEmpty)
 
         r = someIndexes.indexRange(in: 0..<100)
         expectEqual(r.lowerBound, someIndexes.startIndex)
@@ -87,6 +88,9 @@ class TestIndexSet : TestIndexSetSuper {
         r = someIndexes.indexRange(in: 1..<11)
         expectEqual(1, someIndexes[r.lowerBound])
         expectEqual(11, someIndexes[r.upperBound])
+        
+        let empty = IndexSet()
+        expectTrue(empty.indexRange(in: 1..<3).isEmpty)
     }
 
     func testMutation() {
@@ -728,6 +732,36 @@ class TestIndexSet : TestIndexSetSuper {
         }
     }
 
+    func test_findIndex() {
+        var i = IndexSet()
+        
+        // Verify nil result for empty sets
+        expectEqual(nil, i.first)
+        expectEqual(nil, i.last)
+        expectEqual(nil, i.integerGreaterThan(5))
+        expectEqual(nil, i.integerLessThan(5))
+        expectEqual(nil, i.integerGreaterThanOrEqualTo(5))
+        expectEqual(nil, i.integerLessThanOrEqualTo(5))
+        
+        i.insert(integersIn: 5..<10)
+        i.insert(integersIn: 15..<20)
+
+        // Verify non-nil result
+        expectEqual(5, i.first)
+        expectEqual(19, i.last)
+        
+        expectEqual(nil, i.integerGreaterThan(19))
+        expectEqual(5, i.integerGreaterThan(3))
+        
+        expectEqual(nil, i.integerLessThan(5))
+        expectEqual(5, i.integerLessThan(6))
+        
+        expectEqual(nil, i.integerGreaterThanOrEqualTo(20))
+        expectEqual(19, i.integerGreaterThanOrEqualTo(19))
+        
+        expectEqual(nil, i.integerLessThanOrEqualTo(4))
+        expectEqual(5, i.integerLessThanOrEqualTo(5))
+    }
 
     // MARK: -
     // MARK: Performance Testing
@@ -806,6 +840,7 @@ IndexSetTests.test("testSubsequences") { TestIndexSet().testSubsequences() }
 IndexSetTests.test("testFiltering") { TestIndexSet().testFiltering() }
 IndexSetTests.test("testFilteringRanges") { TestIndexSet().testFilteringRanges() }
 IndexSetTests.test("testShift") { TestIndexSet().testShift() }
+IndexSetTests.test("test_findIndex") { TestIndexSet().test_findIndex() }
 // IndexSetTests.test("testIndexingPerformance") { TestIndexSet().testIndexingPerformance() }
 IndexSetTests.test("test_AnyHashableContainingIndexSet") { TestIndexSet().test_AnyHashableContainingIndexSet() }
 IndexSetTests.test("test_AnyHashableCreatedFromNSIndexSet") { TestIndexSet().test_AnyHashableCreatedFromNSIndexSet() }