don't accidentally make the locks public

Author: ktoso

Sources/Prometheus/NIOLock.swift

@@ -216,13 +216,13 @@ extension LockStorage: Sendable {}
 /// of lock is safe to use with `libpthread`-based threading models, such as the
 /// one used by NIO. On Windows, the lock is based on the substantially similar
 /// `SRWLOCK` type.
-public struct NIOLock {
+struct NIOLock {
     @usableFromInline
     internal let _storage: LockStorage<Void>
 
     /// Create a new lock.
     @inlinable
-    public init() {
+    init() {
         self._storage = .create(value: ())
     }
 
@@ -231,7 +231,7 @@ public struct NIOLock {
     /// Whenever possible, consider using `withLock` instead of this method and
     /// `unlock`, to simplify lock handling.
     @inlinable
-    public func lock() {
+    func lock() {
         self._storage.lock()
     }
 
@@ -240,7 +240,7 @@ public struct NIOLock {
     /// Whenever possible, consider using `withLock` instead of this method and
     /// `lock`, to simplify lock handling.
     @inlinable
-    public func unlock() {
+    func unlock() {
         self._storage.unlock()
     }
 
@@ -260,7 +260,7 @@ extension NIOLock {
     /// - Parameter body: The block to execute while holding the lock.
     /// - Returns: The value returned by the block.
     @inlinable
-    public func withLock<T>(_ body: () throws -> T) rethrows -> T {
+    func withLock<T>(_ body: () throws -> T) rethrows -> T {
         self.lock()
         defer {
             self.unlock()
@@ -269,7 +269,7 @@ extension NIOLock {
     }
 
     @inlinable
-    public func withLockVoid(_ body: () throws -> Void) rethrows {
+    func withLockVoid(_ body: () throws -> Void) rethrows {
         try self.withLock(body)
     }
 }

Sources/Prometheus/NIOLockedValueBox.swift

@@ -34,20 +34,21 @@
 /// accesses to a value using the lock. But it's easy to forget to actually
 /// acquire/release the lock in the correct place. ``NIOLockedValueBox`` makes
 /// that much easier.
-public struct NIOLockedValueBox<Value> {
+@usableFromInline
+struct NIOLockedValueBox<Value> {
 
     @usableFromInline
     internal let _storage: LockStorage<Value>
 
     /// Initialize the `Value`.
     @inlinable
-    public init(_ value: Value) {
+    init(_ value: Value) {
         self._storage = .create(value: value)
     }
 
     /// Access the `Value`, allowing mutation of it.
     @inlinable
-    public func withLockedValue<T>(_ mutate: (inout Value) throws -> T) rethrows -> T {
+    func withLockedValue<T>(_ mutate: (inout Value) throws -> T) rethrows -> T {
         try self._storage.withLockedValue(mutate)
     }
 
@@ -56,24 +57,24 @@ public struct NIOLockedValueBox<Value> {
     /// This can be beneficial when you require fine grained control over the lock in some
     /// situations but don't want lose the benefits of ``withLockedValue(_:)`` in others by
     /// switching to ``NIOLock``.
-    public var unsafe: Unsafe {
+    var unsafe: Unsafe {
         Unsafe(_storage: self._storage)
     }
 
     /// Provides an unsafe view over the lock and its value.
-    public struct Unsafe {
+    struct Unsafe {
         @usableFromInline
         let _storage: LockStorage<Value>
 
         /// Manually acquire the lock.
         @inlinable
-        public func lock() {
+        func lock() {
             self._storage.lock()
         }
 
         /// Manually release the lock.
         @inlinable
-        public func unlock() {
+        func unlock() {
             self._storage.unlock()
         }
 
@@ -82,7 +83,7 @@ public struct NIOLockedValueBox<Value> {
         /// - Parameter mutate: A closure with scoped access to the value.
         /// - Returns: The result of the `mutate` closure.
         @inlinable
-        public func withValueAssumingLockIsAcquired<Result>(
+        func withValueAssumingLockIsAcquired<Result>(
             _ mutate: (_ value: inout Value) throws -> Result
         ) rethrows -> Result {
             try self._storage.withUnsafeMutablePointerToHeader { value in