mirror of
https://github.com/apple/swift-collections
synced 2026-11-22 04:20:40 +00:00
138 lines
4.8 KiB
Swift
138 lines
4.8 KiB
Swift
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This source file is part of the Swift Collections open source project
|
|
//
|
|
// Copyright (c) 2021 - 2026 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
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 WITH Swift-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#if !COLLECTIONS_SINGLE_MODULE
|
|
import InternalCollectionsUtilities
|
|
#endif
|
|
|
|
extension BitSet {
|
|
/// Returns a Boolean value that indicates whether the given element exists
|
|
/// in the set.
|
|
///
|
|
/// - Parameter member: An element to look for in the set.
|
|
///
|
|
/// - Returns: `true` if `member` exists in the set; otherwise, `false`.
|
|
///
|
|
/// - Complexity: O(1)
|
|
@usableFromInline
|
|
internal func _contains(_ member: UInt) -> Bool {
|
|
unsafe _read { unsafe $0.contains(member) }
|
|
}
|
|
|
|
/// Returns a Boolean value that indicates whether the given element exists
|
|
/// in the set.
|
|
///
|
|
/// - Parameter member: An element to look for in the set.
|
|
///
|
|
/// - Returns: `true` if `member` exists in the set; otherwise, `false`.
|
|
///
|
|
/// - Complexity: O(1)
|
|
public func contains(_ member: Int) -> Bool {
|
|
guard let member = UInt(exactly: member) else { return false }
|
|
return _contains(member)
|
|
}
|
|
}
|
|
|
|
extension BitSet {
|
|
/// Insert the given element in the set if it is not already present.
|
|
///
|
|
/// If an element equal to `newMember` is already contained in the set, this
|
|
/// method has no effect.
|
|
///
|
|
/// If `newMember` was not already a member, it gets inserted into the set.
|
|
///
|
|
/// - Parameter newMember: An element to insert into the set.
|
|
///
|
|
/// - Returns: True if `newMember` was not contained in the
|
|
/// set, false otherwise.
|
|
///
|
|
/// - Complexity: O(1) if the set is a unique value (with no other copies),
|
|
/// and the inserted value is not greater than the largest value currently
|
|
/// contained in the set (named *max*). Otherwise the complexity is
|
|
/// O(max(`newMember`, *max*)).
|
|
@discardableResult
|
|
@usableFromInline
|
|
internal mutating func _insert(_ newMember: UInt) -> Bool {
|
|
_ensureCapacity(forValue: newMember)
|
|
return unsafe _update { unsafe $0.insert(newMember) }
|
|
}
|
|
|
|
/// Inserts the given element in the set if it is not already present.
|
|
///
|
|
/// If an element equal to `newMember` is already contained in the set, this
|
|
/// method has no effect.
|
|
///
|
|
/// If `newMember` was not already a member, it gets inserted into the set.
|
|
///
|
|
/// - Parameter newMember: An element to insert into the set.
|
|
///
|
|
/// - Returns: `(true, newMember)` if `newMember` was not contained in the
|
|
/// set. If `newMember` was already contained in the set, the method
|
|
/// returns `(false, newMember)`.
|
|
///
|
|
/// - Complexity: O(1) if the set is a unique value (with no other copies),
|
|
/// and the inserted value is not greater than the largest value currently
|
|
/// contained in the set (named *max*). Otherwise the complexity is
|
|
/// O(max(`newMember`, *max*)).
|
|
@discardableResult
|
|
public mutating func insert(
|
|
_ newMember: Int
|
|
) -> (inserted: Bool, memberAfterInsert: Int) {
|
|
guard let i = UInt(exactly: newMember) else {
|
|
preconditionFailure("Value out of range")
|
|
}
|
|
return (_insert(i), newMember)
|
|
}
|
|
|
|
/// Inserts the given element into the set unconditionally.
|
|
///
|
|
/// - Parameter newMember: An element to insert into the set.
|
|
///
|
|
/// - Returns: `newMember` if the set already contained it; otherwise, `nil`.
|
|
///
|
|
/// - Complexity: O(1) if the set is a unique value (with no live copies),
|
|
/// and the inserted value is not greater than the largest value currently
|
|
/// contained in the set (named *max*). Otherwise the complexity is
|
|
/// O(max(`newMember`, *max*)).
|
|
@discardableResult
|
|
public mutating func update(with newMember: Int) -> Int? {
|
|
insert(newMember).inserted ? nil : newMember
|
|
}
|
|
}
|
|
|
|
extension BitSet {
|
|
@discardableResult
|
|
@usableFromInline
|
|
internal mutating func _remove(_ member: UInt) -> Bool {
|
|
unsafe _updateThenShrink { handle, shrink in
|
|
shrink = unsafe handle.remove(member)
|
|
return shrink
|
|
}
|
|
}
|
|
|
|
/// Removes the given element from the set.
|
|
///
|
|
/// - Parameter member: The element of the set to remove.
|
|
///
|
|
/// - Returns: `member` if it was contained in the set; otherwise, `nil`.
|
|
///
|
|
/// - Complexity: O(`1`) if the set is a unique value (with no live copies),
|
|
/// and the removed value is less than the largest value currently in the
|
|
/// set (named *max*). Otherwise the complexity is at worst O(*max*).
|
|
@discardableResult
|
|
public mutating func remove(_ member: Int) -> Int? {
|
|
guard let m = UInt(exactly: member) else { return nil }
|
|
return _remove(m) ? member : nil
|
|
}
|
|
}
|