Use BTreeMerger’s match strategy for BTree comparisons, too.

Also, rename BTreeMergeStrategy to BTreeMatchStrategy.

This fixes #22.

Author: lorentey

Sources/BTreeBuilder.swift

@@ -129,7 +129,22 @@ internal struct BTreeBuilder<Key: Comparable, Value> {
         self.state = .element
     }
 
+    var lastKey: Key? {
+        switch state {
+        case .separator:
+            return saplings.last?.last?.0
+        case .element:
+            return seedling.last?.0 ?? separators.last?.0
+        }
+    }
+
+    func isValidNextKey(_ key: Key) -> Bool {
+        guard let last = lastKey else { return true }
+        return last <= key
+    }
+
     mutating func append(_ element: Element) {
+        assert(isValidNextKey(element.0))
         switch state {
         case .separator:
             separators.append(element)
@@ -154,8 +169,9 @@ internal struct BTreeBuilder<Key: Comparable, Value> {
 
     mutating func appendWithoutCloning(_ node: Node) {
         assert(node.order == order)
+        if node.isEmpty { return }
+        assert(isValidNextKey(node.first!.0))
         if node.depth == 0 {
-            if node.isEmpty { return }
             if state == .separator {
                 assert(seedling.isEmpty)
                 separators.append(node.elements.removeFirst())

Sources/BTreeComparisons.swift

@@ -109,8 +109,8 @@ extension BTree {
     /// - Complexity:
     ///    - O(min(`self.count`, `tree.count`)) in general.
     ///    - O(log(`self.count` + `tree.count`)) if there are only a constant amount of interleaving element runs.
-    public func isSubset(of tree: BTree) -> Bool {
-        return isSubset(of: tree, strict: false)
+    public func isSubset(of tree: BTree, by strategy: BTreeMatchStrategy) -> Bool {
+        return isSubset(of: tree, by: strategy, strict: false)
     }
 
     /// Returns true iff all keys in `self` are also in `tree`,
@@ -119,17 +119,17 @@ extension BTree {
     /// - Complexity:
     ///    - O(min(`self.count`, `tree.count`)) in general.
     ///    - O(log(`self.count` + `tree.count`)) if there are only a constant amount of interleaving element runs.
-    public func isStrictSubset(of tree: BTree) -> Bool {
-        return isSubset(of: tree, strict: true)
+    public func isStrictSubset(of tree: BTree, by strategy: BTreeMatchStrategy) -> Bool {
+        return isSubset(of: tree, by: strategy, strict: true)
     }
 
     /// Returns true iff all keys in `tree` are also in `self`.
     ///
     /// - Complexity:
     ///    - O(min(`self.count`, `tree.count`)) in general.
     ///    - O(log(`self.count` + `tree.count`)) if there are only a constant amount of interleaving element runs.
-    public func isSuperset(of tree: BTree) -> Bool {
-        return tree.isSubset(of: self, strict: false)
+    public func isSuperset(of tree: BTree, by strategy: BTreeMatchStrategy) -> Bool {
+        return tree.isSubset(of: self, by: strategy, strict: false)
     }
 
     /// Returns true iff all keys in `tree` are also in `self`,
@@ -138,55 +138,71 @@ extension BTree {
     /// - Complexity:
     ///    - O(min(`self.count`, `tree.count`)) in general.
     ///    - O(log(`self.count` + `tree.count`)) if there are only a constant amount of interleaving element runs.
-    public func isStrictSuperset(of tree: BTree) -> Bool {
-        return tree.isSubset(of: self, strict: true)
+    public func isStrictSuperset(of tree: BTree, by strategy: BTreeMatchStrategy) -> Bool {
+        return tree.isSubset(of: self, by: strategy, strict: true)
     }
 
-    internal func isSubset(of tree: BTree, strict: Bool) -> Bool {
+    internal func isSubset(of tree: BTree, by strategy: BTreeMatchStrategy, strict: Bool) -> Bool {
         var a = BTreeStrongPath(startOf: self.root)
         var b = BTreeStrongPath(startOf: tree.root)
         var knownStrict = false
-        if !a.isAtEnd && !b.isAtEnd {
-            outer: while true {
-                if a.key < b.key {
-                    return false
-                }
-                while a.key == b.key {
-                    while a.node === b.node && a.slot == b.slot {
-                        // Ascend to first ancestor that isn't shared.
-                        repeat {
-                            a.ascendOneLevel()
-                            b.ascendOneLevel()
-                        } while !a.isAtEnd && !b.isAtEnd && a.node === b.node && a.slot == b.slot
-                        if a.isAtEnd || b.isAtEnd { break outer }
-                        a.ascendToKey()
-                        b.ascendToKey()
-                    }
-                    let key = a.key
+        outer: while !a.isAtEnd && !b.isAtEnd {
+            while a.key == b.key {
+                if a.node === b.node && a.slot == b.slot {
+                    // Ascend to first ancestor that isn't shared.
                     repeat {
+                        a.ascendOneLevel()
+                        b.ascendOneLevel()
+                    } while !a.isAtEnd && a.node === b.node && a.slot == b.slot
+                    if a.isAtEnd || b.isAtEnd { break outer }
+                    a.ascendToKey()
+                    b.ascendToKey()
+                }
+                let key = a.key
+                switch strategy {
+                case .groupingMatches:
+                    while !a.isAtEnd && a.key == key {
                         a.nextPart(until: .including(key))
-                    } while !a.isAtEnd && a.key == key
-                    repeat {
+                    }
+                    while !b.isAtEnd && b.key == key {
                         b.nextPart(until: .including(key))
-                    } while !b.isAtEnd && b.key == key
+                    }
+                    if a.isAtEnd || b.isAtEnd { break outer }
+                case .countingMatches:
+                    var acount = 0
+                    while !a.isAtEnd && a.key == key {
+                        acount += a.nextPart(until: .including(key)).count
+                    }
+                    var bcount = 0
+                    while !b.isAtEnd && b.key == key {
+                        bcount += b.nextPart(until: .including(key)).count
+                    }
+                    if acount > bcount {
+                        return false
+                    }
+                    if acount < bcount {
+                        knownStrict = true
+                    }
                     if a.isAtEnd || b.isAtEnd { break outer }
-                }
-                while b.key < a.key {
-                    knownStrict = true
-                    b.nextPart(until: .excluding(a.key))
-                    if b.isAtEnd { return false }
                 }
             }
+            if a.key < b.key {
+                return false
+            }
+            while b.key < a.key {
+                knownStrict = true
+                b.nextPart(until: .excluding(a.key))
+                if b.isAtEnd { return false }
+            }
         }
+
         if a.isAtEnd {
             if !b.isAtEnd {
                 return true
             }
         }
-        else {
-            if b.isAtEnd {
-                return false
-            }
+        else if b.isAtEnd {
+            return false
         }
         return !strict || knownStrict
     }

Sources/BTreeMerger.swift

@@ -6,7 +6,7 @@
 //  Copyright © 2016 Károly Lőrentey.
 //
 
-public enum BTreeMergeStrategy {
+public enum BTreeMatchStrategy {
     case groupingMatches
     case countingMatches
 }
@@ -40,7 +40,7 @@ extension BTree {
     /// - Complexity:
     ///    - O(min(`self.count`, `other.count`)) in general.
     ///    - O(log(`self.count` + `other.count`)) if there are only a constant amount of interleaving element runs.
-    public func union(_ other: BTree, by strategy: BTreeMergeStrategy) -> BTree {
+    public func union(_ other: BTree, by strategy: BTreeMatchStrategy) -> BTree {
         var m = BTreeMerger(first: self, second: other)
         switch strategy {
         case .groupingMatches:
@@ -84,7 +84,7 @@ extension BTree {
     /// - Complexity:
     ///    - O(min(`self.count`, `tree.count`)) in general.
     ///    - O(log(`self.count` + `tree.count`)) if there are only a constant amount of interleaving element runs.
-    public func subtracting(_ other: BTree, by strategy: BTreeMergeStrategy) -> BTree {
+    public func subtracting(_ other: BTree, by strategy: BTreeMatchStrategy) -> BTree {
         var m = BTreeMerger(first: self, second: other)
         while !m.done {
             m.copyFromFirst(.excludingOtherKey)
@@ -127,7 +127,7 @@ extension BTree {
     /// - Complexity:
     ///    - O(min(`self.count`, `other.count`)) in general.
     ///    - O(log(`self.count` + `other.count`)) if there are only a constant amount of interleaving element runs.
-    public func symmetricDifference(_ other: BTree, by strategy: BTreeMergeStrategy) -> BTree {
+    public func symmetricDifference(_ other: BTree, by strategy: BTreeMatchStrategy) -> BTree {
         var m = BTreeMerger(first: self, second: other)
         while !m.done {
             m.copyFromFirst(.excludingOtherKey)
@@ -171,7 +171,7 @@ extension BTree {
     /// - Complexity:
     ///    - O(min(`self.count`, `other.count`)) in general.
     ///    - O(log(`self.count` + `other.count`)) if there are only a constant amount of interleaving element runs.
-    public func intersection(_ other: BTree, by strategy: BTreeMergeStrategy) -> BTree {
+    public func intersection(_ other: BTree, by strategy: BTreeMatchStrategy) -> BTree {
         var m = BTreeMerger(first: self, second: other)
         while !m.done {
             m.skipFromFirst(.excludingOtherKey)
@@ -195,7 +195,7 @@ extension BTree {
     ///
     /// - Requires: `sortedKeys` is sorted in ascending order.
     /// - Complexity: O(*n* + `self.count`), where *n* is the number of keys in `sortedKeys`.
-    public func subtracting<S: Sequence>(sortedKeys: S, by strategy: BTreeMergeStrategy) -> BTree where S.Iterator.Element == Key {
+    public func subtracting<S: Sequence>(sortedKeys: S, by strategy: BTreeMatchStrategy) -> BTree where S.Iterator.Element == Key {
         if self.isEmpty { return self }
 
         var b = BTreeBuilder<Key, Value>(order: self.order)
@@ -237,7 +237,7 @@ extension BTree {
     ///
     /// - Requires: `sortedKeys` is sorted in ascending order.
     /// - Complexity: O(*n* + `self.count`), where *n* is the number of keys in `sortedKeys`.
-    public func intersection<S: Sequence>(sortedKeys: S, by strategy: BTreeMergeStrategy) -> BTree where S.Iterator.Element == Key {
+    public func intersection<S: Sequence>(sortedKeys: S, by strategy: BTreeMatchStrategy) -> BTree where S.Iterator.Element == Key {
         if self.isEmpty { return self }
 
         var b = BTreeBuilder<Key, Value>(order: self.order)
@@ -481,8 +481,9 @@ internal struct BTreeMerger<Key: Comparable, Value> {
                 var common: Node
                 repeat {
                     key = a.node.last!.0
+                    common = a.node
                     a.ascendOneLevel()
-                    common = b.ascendOneLevel()
+                    b.ascendOneLevel()
                 } while !a.isAtEnd && !b.isAtEnd && a.node === b.node && a.slot == 0 && b.slot == 0
                 builder.append(common)
                 if !a.isAtEnd {
@@ -518,8 +519,9 @@ internal struct BTreeMerger<Key: Comparable, Value> {
                 /// the shared subtree. The slot & leaf checks above & below ensure that this isn't the case.
                 var common: Node
                 repeat {
+                    common = a.node
                     a.ascendOneLevel()
-                    common = b.ascendOneLevel()
+                    b.ascendOneLevel()
                 } while !a.isAtEnd && !b.isAtEnd && a.node === b.node && a.slot == 0 && b.slot == 0
                 builder.append(common)
                 if !a.isAtEnd { a.ascendToKey() }
@@ -589,7 +591,7 @@ internal struct BTreeMerger<Key: Comparable, Value> {
 
     mutating func skipMatchingNumberOfCommonElements() {
         while !done && a.key == b.key {
-            if a.node === b.node && a.node.isLeaf && a.slot == 0 && b.slot == 0 {
+            if a.node === b.node && a.node.isLeaf && a.slot == b.slot {
                 /// We're at the first element of a shared subtree. Find the ancestor at which the shared subtree
                 /// starts, and append it in a single step.
                 ///
@@ -602,7 +604,7 @@ internal struct BTreeMerger<Key: Comparable, Value> {
                     if a.isAtEnd || b.isAtEnd {
                         done = true
                     }
-                } while !done && a.node === b.node && a.slot == 0 && b.slot == 0
+                } while !done && a.node === b.node && a.slot == b.slot
                 if !a.isAtEnd { a.ascendToKey() }
                 if !b.isAtEnd { b.ascendToKey() }
             }
@@ -622,6 +624,25 @@ internal enum BTreePart<Key: Comparable, Value> {
     case nodeRange(BTreeNode<Key, Value>, CountableRange<Int>)
 }
 
+extension BTreePart {
+    var count: Int {
+        switch self {
+        case .element(_, _):
+            return 1
+        case .node(let node):
+            return node.count
+        case .nodeRange(let parent, let range):
+            var count = range.count
+            if !parent.isLeaf {
+                for i in range.lowerBound ... range.upperBound {
+                    count += parent.children[i].count
+                }
+            }
+            return count
+        }
+    }
+}
+
 extension BTreeBuilder {
     mutating func append(_ part: BTreePart<Key, Value>) {
         switch part {
@@ -668,16 +689,14 @@ internal extension BTreeStrongPath {
 
     /// Remove the deepest path component, leaving the path at the element following the node that was previously focused,
     /// or the spot after all elements if the node was the rightmost child.
-    @discardableResult
-    mutating func ascendOneLevel() -> Node {
+    mutating func ascendOneLevel() {
         if length == 1 {
             offset = count
             slot = node.elements.count
-            return node
+            return
         }
         popFromSlots()
         popFromPath()
-        return node.children[slot!]
     }
 
     /// If this path got to a slot at the end of a node but it hasn't reached the end of the tree yet,
@@ -704,10 +723,9 @@ internal extension BTreeStrongPath {
         assert(!isAtEnd)
         var includeLeftmostSubtree = false
         if slot == 0 && node.isLeaf {
-            while slot == 0 {
-                guard let pk = parentKey else { break }
-                guard limit.match(pk) else { break }
-                ascendOneLevel()
+            while slot == 0, let pk = parentKey, limit.match(pk) {
+                popFromSlots()
+                popFromPath()
                 includeLeftmostSubtree = true
             }
         }

Sources/SortedBag.swift

@@ -536,7 +536,7 @@ extension SortedBag {
     ///    - O(min(`self.count`, `other.count`)) in general.
     ///    - O(log(`self.count` + `other.count`)) if there are only a constant amount of interleaving element runs.
     public func isSubset(of other: SortedBag<Element>) -> Bool {
-        return tree.isSubset(of: other.tree)
+        return tree.isSubset(of: other.tree, by: .countingMatches)
     }
 
     /// Returns `true` iff all members in this bag are also included in `other`, but the two bags aren't equal.
@@ -549,7 +549,7 @@ extension SortedBag {
     ///    - O(min(`self.count`, `other.count`)) in general.
     ///    - O(log(`self.count` + `other.count`)) if there are only a constant amount of interleaving element runs.
     public func isStrictSubset(of other: SortedBag<Element>) -> Bool {
-        return tree.isStrictSubset(of: other.tree)
+        return tree.isStrictSubset(of: other.tree, by: .countingMatches)
     }
 
     /// Returns `true` iff all members in `other` are also included in this bag.
@@ -562,7 +562,7 @@ extension SortedBag {
     ///    - O(min(`self.count`, `other.count`)) in general.
     ///    - O(log(`self.count` + `other.count`)) if there are only a constant amount of interleaving element runs.
     public func isSuperset(of other: SortedBag<Element>) -> Bool {
-        return tree.isSuperset(of: other.tree)
+        return tree.isSuperset(of: other.tree, by: .countingMatches)
     }
 
     /// Returns `true` iff all members in `other` are also included in this bag, but the two bags aren't equal.
@@ -575,7 +575,7 @@ extension SortedBag {
     ///    - O(min(`self.count`, `other.count`)) in general.
     ///    - O(log(`self.count` + `other.count`)) if there are only a constant amount of interleaving element runs.
     public func isStrictSuperset(of other: SortedBag<Element>) -> Bool {
-        return tree.isStrictSuperset(of: other.tree)
+        return tree.isStrictSuperset(of: other.tree, by: .countingMatches)
     }
 }