[Basic] Conform OrderedSet to MutableCollection

Author: aciidgh

Sources/Basic/OrderedSet.swift

@@ -10,7 +10,7 @@
 
 /// An ordered set is an ordered collection of instances of `Element` in which
 /// uniqueness of the objects is guaranteed.
-public struct OrderedSet<E: Hashable>: Equatable, Collection {
+public struct OrderedSet<E: Hashable>: Equatable, MutableCollection, RandomAccessCollection {
     public typealias Element = E
     public typealias Index = Int
     public typealias Indices = CountableRange<Int>
@@ -77,6 +77,39 @@ public struct OrderedSet<E: Hashable>: Equatable, Collection {
         array.removeAll(keepingCapacity: keepCapacity)
         set.removeAll(keepingCapacity: keepCapacity)
     }
+
+    // MARK:- MutableCollection, RandomAccessCollection conformance
+
+    public var startIndex: Int { return contents.startIndex }
+    public var endIndex: Int { return contents.endIndex }
+
+    public subscript(position: Int) -> Element {
+        get {
+            return array[position]
+        }
+        set(newValue) {
+            let oldValue = array[position]
+            // Remove the old value from set.
+            set.remove(oldValue)
+            // Add the new value.
+            array[position] = newValue
+            set.insert(newValue)
+        }
+    }
+
+    public subscript(bounds: Range<Int>) -> ArraySlice<Element> {
+        get {
+            return array[bounds]
+        }
+        set(newValues) {
+            let oldValues = array[bounds]
+            // Remove the old values from set.
+            oldValues.forEach{ set.remove($0) }
+            // Add the new values.
+            array[bounds] = newValues
+            newValues.forEach{ set.insert($0) }
+        }
+    }
 }
 
 extension OrderedSet: ExpressibleByArrayLiteral {
@@ -89,14 +122,6 @@ extension OrderedSet: ExpressibleByArrayLiteral {
     }
 }
 
-extension OrderedSet: RandomAccessCollection {
-    public var startIndex: Int { return contents.startIndex }
-    public var endIndex: Int { return contents.endIndex }
-    public subscript(i: Int) -> Element {
-      return contents[i]
-    }
-}
-
 public func ==<T>(lhs: OrderedSet<T>, rhs: OrderedSet<T>) -> Bool {
     return lhs.contents == rhs.contents
 }

Tests/BasicTests/OrderedSetTests.swift

@@ -51,7 +51,34 @@ class OrderedSetTests: XCTestCase {
         XCTAssertEqual(set.contents, [])
     }
 
+    func testMutation() {
+        var set = OrderedSet<Int>()
+        set.append(1)
+        set.append(2)
+        set.append(3)
+        XCTAssertEqual(set.contents, [1, 2, 3])
+
+        set[0] = 4
+        XCTAssertEqual(set.contents, [4, 2, 3])
+        XCTAssertFalse(set.contains(1))
+        XCTAssert(set.contains(4))
+
+        set[2] = 9
+        XCTAssertEqual(set.contents, [4, 2, 9])
+        XCTAssertFalse(set.contains(3))
+        XCTAssert(set.contains(9))
+
+        XCTAssertEqual(set[0..<2], [4, 2])
+        set[0..<2] = [6, 7]
+        XCTAssertEqual(set, [6, 7, 9])
+        XCTAssertFalse(set.contains(4))
+        XCTAssert(set.contains(6))
+        XCTAssertFalse(set.contains(2))
+        XCTAssert(set.contains(7))
+    }
+
     static var allTests = [
         ("testBasics", testBasics),
+        ("testMutation", testMutation),
     ]
 }