Files
swift-collections/Sources/DequeModule/Deque+MutableCollection.swift
T
Karoy Lorentey a2bcac435f Initial import.
Introduce OrderedCollections module
2021-04-05 09:41:00 -07:00

84 lines
3.3 KiB
Swift

//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift Collections open source project
//
// Copyright (c) 2021 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
//
//===----------------------------------------------------------------------===//
extension Deque: MutableCollection {
/// Exchanges the values at the specified indices of the collection.
///
/// Both parameters must be valid indices of the collection and not equal to
/// `endIndex`. Passing the same index as both `i` and `j` has no effect.
///
/// - Parameters:
/// - i: The index of the first value to swap.
/// - j: The index of the second value to swap.
///
/// - Complexity: O(1) when this instance has a unique reference to its
/// underlying storage; O(`count`) otherwise.
@inlinable
public mutating func swapAt(_ i: Index, _ j: Index) {
precondition(i >= 0 && i < count, "Index out of bounds")
precondition(j >= 0 && j < count, "Index out of bounds")
_storage.ensureUnique()
_storage.update { handle in
let slot1 = handle.slot(forOffset: i)
let slot2 = handle.slot(forOffset: j)
handle.mutableBuffer.swapAt(slot1.position, slot2.position)
}
}
// FIXME: Implement `partition(by:)` by making storage contiguous,
// and partitioning that.
/// Call `body(b)`, where `b` is an unsafe buffer pointer to the deque's
/// mutable contiguous storage. If the deque's contents aren't stored
/// contiguously, `body` is not called and `nil` is returned. The supplied
/// buffer pointer is only valid for the duration of the call.
///
/// Often, the optimizer can eliminate bounds- and uniqueness-checks within an
/// algorithm, but when that fails, invoking the same algorithm on the unsafe
/// buffer supplied to `body` lets you trade safety for speed.
///
/// - Parameters:
/// - body: The function to invoke.
///
/// - Returns: The value returned by `body`, or `nil` if `body` wasn't called.
///
/// - Complexity: O(1) when this instance has a unique reference to its
/// underlying storage; O(`count`) otherwise. (Not counting the call to
/// `body`.)
@inlinable
public mutating func withContiguousMutableStorageIfAvailable<R>(
_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R
) rethrows -> R? {
_storage.ensureUnique()
return try _storage.update { handle in
let endSlot = handle.startSlot.advanced(by: handle.count)
guard endSlot.position <= handle.capacity else {
// FIXME: Rotate storage such that it becomes contiguous.
return nil
}
let original = handle.mutableBuffer(for: handle.startSlot ..< endSlot)
var extract = original
defer {
precondition(extract.baseAddress == original.baseAddress && extract.count == original.count,
"Closure must not replace the provided buffer")
}
return try body(&extract)
}
}
@inlinable
public mutating func _withUnsafeMutableBufferPointerIfSupported<R>(
_ body: (inout UnsafeMutableBufferPointer<Element>) throws -> R
) rethrows -> R? {
return try withContiguousMutableStorageIfAvailable(body)
}
}