//===----------------------------------------------------------------------===// // // 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 BitArray { internal mutating func _copy( from range: Range, to target: Int ) { unsafe _update { handle in unsafe handle.copy(from: range, to: target) } } internal mutating func _copy( from range: Range, in source: UnsafeBufferPointer<_Word>, to target: Int ) { unsafe _update { handle in unsafe handle.copy(from: range, in: source, to: target) } } internal mutating func _copy( from source: BitArray, to target: Int ) { _copy(from: source[...], to: target) } internal mutating func _copy( from source: BitArray.SubSequence, to target: Int ) { let range = source._bounds source.base._storage.withUnsafeBufferPointer { words in unsafe self._copy(from: range, in: words, to: target) } } internal mutating func _copy( from source: S, to range: Range ) where S.Element == Bool { unsafe _update { unsafe $0.copy(from: source, to: range) } } } extension BitArray._UnsafeHandle { internal mutating func _copy( bits: _Word, count: UInt, to target: _BitPosition ) { assert(count <= _Word.capacity) assert(count == _Word.capacity || bits.shiftedDown(by: count).isEmpty) assert(target.value + count <= self.count) let start = target.split let end = _BitPosition(target.value + count).endSplit let words = unsafe _mutableWords if start.word == end.word { let mask = _Word(from: start.bit, to: end.bit) unsafe words[start.word].formIntersection(mask.complement()) unsafe words[start.word].formUnion(bits.shiftedUp(by: start.bit)) return } assert(start.word + 1 == end.word) unsafe words[start.word].formIntersection(_Word(upTo: start.bit)) unsafe words[start.word].formUnion(bits.shiftedUp(by: start.bit)) unsafe words[end.word].formIntersection(_Word(upTo: end.bit).complement()) unsafe words[end.word].formUnion( bits.shiftedDown(by: _Word._capacity &- start.bit)) } internal mutating func copy( from range: Range, to target: Int ) { assert( range.lowerBound >= 0 && range.upperBound <= self.count, "Source range out of bounds") unsafe copy(from: range, in: _words, to: target) } internal mutating func copy( from range: Range, in source: UnsafeBufferPointer<_Word>, to target: Int ) { ensureMutable() assert( range.lowerBound >= 0 && range.upperBound <= source.count * _Word.capacity, "Source range out of bounds") assert( target >= 0 && target + range.count <= count, "Target out of bounds") guard !range.isEmpty else { return } func goForward() -> Bool { let target = _BitPosition(target).split let lowerSource = _BitPosition(range.lowerBound).split let upperSource = _BitPosition(range.upperBound).endSplit let targetPtr = unsafe _words._ptr(at: target.word) let lowerSourcePtr = unsafe source._ptr(at: lowerSource.word) let upperSourcePtr = unsafe source._ptr(at: upperSource.word) if unsafe targetPtr < lowerSourcePtr || targetPtr > upperSourcePtr { return true } if unsafe targetPtr == lowerSourcePtr, target.bit < lowerSource.bit { return true } if unsafe targetPtr == upperSourcePtr, target.bit >= upperSource.bit { return true } return false } if goForward() { // Copy forward from a disjoint or following overlapping range. var src = unsafe _ChunkedBitsForwardIterator(words: source, range: range) var dst = _BitPosition(target) while let (bits, count) = unsafe src.next() { unsafe _copy(bits: bits, count: count, to: dst) dst.value += count } assert(dst.value == target + range.count) } else { // Copy backward from a non-following overlapping range. var src = unsafe _ChunkedBitsBackwardIterator(words: source, range: range) var dst = _BitPosition(target + range.count) while let (bits, count) = unsafe src.next() { dst.value -= count unsafe _copy(bits: bits, count: count, to: dst) } assert(dst.value == target) } } } extension BitArray._UnsafeHandle { internal mutating func copy( from source: some Sequence, to range: Range ) { assert(range.lowerBound >= 0 && range.upperBound <= self.count) var pos = _BitPosition(range.lowerBound) var it = source.makeIterator() if pos.bit > 0 { let (bits, count) = it._nextChunk( maxCount: _Word._capacity - pos.bit) unsafe _copy(bits: bits, count: count, to: pos) pos.value += count } while true { let (bits, count) = it._nextChunk() guard count > 0 else { break } assert(pos.bit == 0) unsafe _copy(bits: bits, count: count, to: pos) pos.value += count } precondition(pos.value == range.upperBound) } }