1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Collections open source project
//
// Copyright (c) 2021 - 2024 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
//
//===----------------------------------------------------------------------===//
#if !COLLECTIONS_SINGLE_MODULE
import InternalCollectionsUtilities
#endif
// `OrderedSet` does not directly conform to `SetAlgebra` because its definition
// of equality conflicts with `SetAlgebra` requirements. However, it still
// implements most `SetAlgebra` requirements (except `insert`, which is replaced
// by `append`).
//
// `OrderedSet` also provides an `unordered` view that explicitly conforms to
// `SetAlgebra`. That view implements `Equatable` by ignoring element order,
// so it can satisfy `SetAlgebra` requirements.
extension OrderedSet {
/// Returns a Boolean value that indicates whether the set has no members in
/// common with the given set.
///
/// let a: OrderedSet = [1, 2, 3, 4]
/// let b: OrderedSet = [5, 6]
/// a.isDisjoint(with: b) // true
///
/// - Parameter other: Another set.
///
/// - Returns: `true` if `self` has no elements in common with `other`;
/// otherwise, `false`.
///
/// - Complexity: Expected to be O(min(`self.count`, `other.count`)) on
/// average, if `Element` implements high-quality hashing.
@inlinable
public func isDisjoint(with other: Self) -> Bool {
guard !self.isEmpty && !other.isEmpty else { return true }
if self.count <= other.count {
for item in self {
if other.contains(item) { return false }
}
} else {
for item in other {
if self.contains(item) { return false }
}
}
return true
}
// Generalizations
/// Returns a Boolean value that indicates whether the set has no members in
/// common with the given set.
///
/// let a: OrderedSet = [1, 2, 3, 4]
/// let b: OrderedSet = [5, 6]
/// a.isDisjoint(with: b.unordered) // true
///
/// - Parameter other: Another set.
///
/// - Returns: `true` if `self` has no elements in common with `other`;
/// otherwise, `false`.
///
/// - Complexity: Expected to be O(min(`self.count`, `other.count`)) on
/// average, if `Element` implements high-quality hashing.
@inlinable
@inline(__always)
public func isDisjoint(with other: UnorderedView) -> Bool {
isDisjoint(with: other._base)
}
/// Returns a Boolean value that indicates whether the set has no members in
/// common with the given set.
///
/// let a: OrderedSet = [1, 2, 3, 4]
/// let b: Set = [5, 6]
/// a.isDisjoint(with: b) // true
///
/// - Parameter other: Another set.
///
/// - Returns: `true` if `self` has no elements in common with `other`;
/// otherwise, `false`.
///
/// - Complexity: Expected to be O(min(`self.count`, `other.count`)) on
/// average, if `Element` implements high-quality hashing.
@inlinable
public func isDisjoint(with other: Set<Element>) -> Bool {
guard !self.isEmpty && !other.isEmpty else { return true }
if self.count <= other.count {
for item in self {
if other.contains(item) { return false }
}
} else {
for item in other {
if self.contains(item) { return false }
}
}
return true
}
/// Returns a Boolean value that indicates whether the set has no members in
/// common with the given sequence.
///
/// let a: OrderedSet = [1, 2, 3, 4]
/// let b: Array = [5, 6]
/// a.isDisjoint(with: b) // true
///
/// - Parameter other: A finite sequence of elements.
///
/// - Returns: `true` if `self` has no elements in common with `other`;
/// otherwise, `false`.
///
/// - Complexity: Expected to be O(*n*) on average, where *n* is the number of
/// elements in `other`, if `Element` implements high-quality hashing.
@inlinable
public func isDisjoint(
with other: some Sequence<Element>
) -> Bool {
guard !self.isEmpty else { return true }
for item in other {
if self.contains(item) { return false }
}
return true
}
}
|
