format Lock.swift with swift-nio .swift-format settings

Author: simonjbeaumont

Sources/OpenAPIURLSession/BufferedStream/Lock.swift

@@ -47,56 +47,56 @@ typealias LockPrimitive = pthread_mutex_t
 enum LockOperations {}
 
 extension LockOperations {
-  @inlinable
-  static func create(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
-    mutex.assertValidAlignment()
-
-    #if os(Windows)
-    InitializeSRWLock(mutex)
-    #else
-    var attr = pthread_mutexattr_t()
-    pthread_mutexattr_init(&attr)
-
-    let err = pthread_mutex_init(mutex, &attr)
-    precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
-    #endif
-  }
-
-  @inlinable
-  static func destroy(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
-    mutex.assertValidAlignment()
-
-    #if os(Windows)
-    // SRWLOCK does not need to be freed
-    #else
-    let err = pthread_mutex_destroy(mutex)
-    precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
-    #endif
-  }
-
-  @inlinable
-  static func lock(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
-    mutex.assertValidAlignment()
-
-    #if os(Windows)
-    AcquireSRWLockExclusive(mutex)
-    #else
-    let err = pthread_mutex_lock(mutex)
-    precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
-    #endif
-  }
-
-  @inlinable
-  static func unlock(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
-    mutex.assertValidAlignment()
-
-    #if os(Windows)
-    ReleaseSRWLockExclusive(mutex)
-    #else
-    let err = pthread_mutex_unlock(mutex)
-    precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
-    #endif
-  }
+    @inlinable
+    static func create(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
+        mutex.assertValidAlignment()
+
+        #if os(Windows)
+        InitializeSRWLock(mutex)
+        #else
+        var attr = pthread_mutexattr_t()
+        pthread_mutexattr_init(&attr)
+
+        let err = pthread_mutex_init(mutex, &attr)
+        precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
+        #endif
+    }
+
+    @inlinable
+    static func destroy(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
+        mutex.assertValidAlignment()
+
+        #if os(Windows)
+        // SRWLOCK does not need to be freed
+        #else
+        let err = pthread_mutex_destroy(mutex)
+        precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
+        #endif
+    }
+
+    @inlinable
+    static func lock(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
+        mutex.assertValidAlignment()
+
+        #if os(Windows)
+        AcquireSRWLockExclusive(mutex)
+        #else
+        let err = pthread_mutex_lock(mutex)
+        precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
+        #endif
+    }
+
+    @inlinable
+    static func unlock(_ mutex: UnsafeMutablePointer<LockPrimitive>) {
+        mutex.assertValidAlignment()
+
+        #if os(Windows)
+        ReleaseSRWLockExclusive(mutex)
+        #else
+        let err = pthread_mutex_unlock(mutex)
+        precondition(err == 0, "\(#function) failed in pthread_mutex with error \(err)")
+        #endif
+    }
 }
 
 // Tail allocate both the mutex and a generic value using ManagedBuffer.
@@ -130,59 +130,59 @@ extension LockOperations {
 @usableFromInline
 final class LockStorage<Value>: ManagedBuffer<Value, LockPrimitive> {
 
-  @inlinable
-  static func create(value: Value) -> Self {
-    let buffer = Self.create(minimumCapacity: 1) { _ in
-      return value
-    }
-    // Avoid 'unsafeDowncast' as there is a miscompilation on 5.10.
-    let storage = buffer as! Self
+    @inlinable
+    static func create(value: Value) -> Self {
+        let buffer = Self.create(minimumCapacity: 1) { _ in
+            value
+        }
+        // Avoid 'unsafeDowncast' as there is a miscompilation on 5.10.
+        let storage = buffer as! Self
 
-    storage.withUnsafeMutablePointers { _, lockPtr in
-      LockOperations.create(lockPtr)
-    }
+        storage.withUnsafeMutablePointers { _, lockPtr in
+            LockOperations.create(lockPtr)
+        }
 
-    return storage
-  }
+        return storage
+    }
 
-  @inlinable
-  func lock() {
-    self.withUnsafeMutablePointerToElements { lockPtr in
-      LockOperations.lock(lockPtr)
+    @inlinable
+    func lock() {
+        self.withUnsafeMutablePointerToElements { lockPtr in
+            LockOperations.lock(lockPtr)
+        }
     }
-  }
 
-  @inlinable
-  func unlock() {
-    self.withUnsafeMutablePointerToElements { lockPtr in
-      LockOperations.unlock(lockPtr)
+    @inlinable
+    func unlock() {
+        self.withUnsafeMutablePointerToElements { lockPtr in
+            LockOperations.unlock(lockPtr)
+        }
     }
-  }
 
-  @usableFromInline
-  deinit {
-    self.withUnsafeMutablePointerToElements { lockPtr in
-      LockOperations.destroy(lockPtr)
+    @usableFromInline
+    deinit {
+        self.withUnsafeMutablePointerToElements { lockPtr in
+            LockOperations.destroy(lockPtr)
+        }
     }
-  }
-
-  @inlinable
-  func withLockPrimitive<T>(
-    _ body: (UnsafeMutablePointer<LockPrimitive>) throws -> T
-  ) rethrows -> T {
-    try self.withUnsafeMutablePointerToElements { lockPtr in
-      return try body(lockPtr)
+
+    @inlinable
+    func withLockPrimitive<T>(
+        _ body: (UnsafeMutablePointer<LockPrimitive>) throws -> T
+    ) rethrows -> T {
+        try self.withUnsafeMutablePointerToElements { lockPtr in
+            try body(lockPtr)
+        }
     }
-  }
-
-  @inlinable
-  func withLockedValue<T>(_ mutate: (inout Value) throws -> T) rethrows -> T {
-    try self.withUnsafeMutablePointers { valuePtr, lockPtr in
-      LockOperations.lock(lockPtr)
-      defer { LockOperations.unlock(lockPtr) }
-      return try mutate(&valuePtr.pointee)
+
+    @inlinable
+    func withLockedValue<T>(_ mutate: (inout Value) throws -> T) rethrows -> T {
+        try self.withUnsafeMutablePointers { valuePtr, lockPtr in
+            LockOperations.lock(lockPtr)
+            defer { LockOperations.unlock(lockPtr) }
+            return try mutate(&valuePtr.pointee)
+        }
     }
-  }
 }
 
 extension LockStorage: @unchecked Sendable {}
@@ -197,83 +197,83 @@ extension LockStorage: @unchecked Sendable {}
 /// `SRWLOCK` type.
 @usableFromInline
 struct Lock {
-  @usableFromInline
-  internal let _storage: LockStorage<Void>
-
-  /// Create a new lock.
-  @usableFromInline
-  init() {
-    self._storage = .create(value: ())
-  }
-
-  /// Acquire the lock.
-  ///
-  /// Whenever possible, consider using `withLock` instead of this method and
-  /// `unlock`, to simplify lock handling.
-  @inlinable
-  func lock() {
-    self._storage.lock()
-  }
-
-  /// Release the lock.
-  ///
-  /// Whenever possible, consider using `withLock` instead of this method and
-  /// `lock`, to simplify lock handling.
-  @inlinable
-  func unlock() {
-    self._storage.unlock()
-  }
-
-  @inlinable
-  internal func withLockPrimitive<T>(
-    _ body: (UnsafeMutablePointer<LockPrimitive>) throws -> T
-  ) rethrows -> T {
-    return try self._storage.withLockPrimitive(body)
-  }
+    @usableFromInline
+    internal let _storage: LockStorage<Void>
+
+    /// Create a new lock.
+    @usableFromInline
+    init() {
+        self._storage = .create(value: ())
+    }
+
+    /// Acquire the lock.
+    ///
+    /// Whenever possible, consider using `withLock` instead of this method and
+    /// `unlock`, to simplify lock handling.
+    @inlinable
+    func lock() {
+        self._storage.lock()
+    }
+
+    /// Release the lock.
+    ///
+    /// Whenever possible, consider using `withLock` instead of this method and
+    /// `lock`, to simplify lock handling.
+    @inlinable
+    func unlock() {
+        self._storage.unlock()
+    }
+
+    @inlinable
+    internal func withLockPrimitive<T>(
+        _ body: (UnsafeMutablePointer<LockPrimitive>) throws -> T
+    ) rethrows -> T {
+        try self._storage.withLockPrimitive(body)
+    }
 }
 
 extension Lock {
-  /// Acquire the lock for the duration of the given block.
-  ///
-  /// This convenience method should be preferred to `lock` and `unlock` in
-  /// most situations, as it ensures that the lock will be released regardless
-  /// of how `body` exits.
-  ///
-  /// - Parameter body: The block to execute while holding the lock.
-  /// - Returns: The value returned by the block.
-  @inlinable
-  func withLock<T>(_ body: () throws -> T) rethrows -> T {
-    self.lock()
-    defer {
-      self.unlock()
+    /// Acquire the lock for the duration of the given block.
+    ///
+    /// This convenience method should be preferred to `lock` and `unlock` in
+    /// most situations, as it ensures that the lock will be released regardless
+    /// of how `body` exits.
+    ///
+    /// - Parameter body: The block to execute while holding the lock.
+    /// - Returns: The value returned by the block.
+    @inlinable
+    func withLock<T>(_ body: () throws -> T) rethrows -> T {
+        self.lock()
+        defer {
+            self.unlock()
+        }
+        return try body()
     }
-    return try body()
-  }
 }
 
 extension Lock: Sendable {}
 
 extension UnsafeMutablePointer {
-  @inlinable
-  func assertValidAlignment() {
-    assert(UInt(bitPattern: self) % UInt(MemoryLayout<Pointee>.alignment) == 0)
-  }
+    @inlinable
+    func assertValidAlignment() {
+        assert(UInt(bitPattern: self) % UInt(MemoryLayout<Pointee>.alignment) == 0)
+    }
 }
 
 @usableFromInline
 struct LockedValueBox<Value> {
-  @usableFromInline
-  let storage: LockStorage<Value>
-
-  @usableFromInline
-  init(_ value: Value) {
-    self.storage = .create(value: value)
-  }
-
-  @inlinable
-  func withLockedValue<T>(_ mutate: (inout Value) throws -> T) rethrows -> T {
-    return try self.storage.withLockedValue(mutate)
-  }
+    @usableFromInline
+    let storage: LockStorage<Value>
+
+    @usableFromInline
+    init(_ value: Value) {
+        self.storage = .create(value: value)
+    }
+
+    @inlinable
+    func withLockedValue<T>(_ mutate: (inout Value) throws -> T) rethrows -> T {
+        try self.storage.withLockedValue(mutate)
+    }
 }
 
 extension LockedValueBox: Sendable where Value: Sendable {}