Make NdbBlock ~Copyable for better lifetime safety

Changelog-None
Closes: https://github.com/damus-io/damus/issues/3127
Signed-off-by: Daniel D’Aquino <daniel@daquino.me>

nostrdb/NonCopyableLinkedList.swift

@@ -0,0 +1,160 @@
+//
+//  NonCopyableLinkedList.swift
+//  damus
+//
+//  Created by Daniel D’Aquino on 2025-07-04.
+//
+
+/// A linked list to help with iteration of non-copyable elements
+///
+/// This is needed to provide an array-like abstraction or iterators since swift arrays or iterator protocols require the element to be "copyable"
+struct NonCopyableLinkedList<T: ~Copyable>: ~Copyable {
+    private var head: Node<T>? = nil
+    private var tail: Node<T>? = nil
+    private(set) var count: Int = 0
+    
+    /// Iterates over each item of the list, with enumeration support.
+    func forEachItem<Y>(_ borrowingFunction: ((_ index: Int, _ item: borrowing T) throws -> LoopCommand<Y>)) rethrows -> Y?  {
+        var indexCounter = 0
+        
+        var cursor: Node? = self.head
+        
+        outerLoop: while let nextItem = cursor {
+            let loopIterationResult = try borrowingFunction(indexCounter, nextItem.value)
+            indexCounter += 1
+            cursor = nextItem.next
+            switch loopIterationResult {
+            case .loopBreak:
+                break outerLoop
+            case .loopContinue:
+                continue outerLoop
+            case .loopReturn(let result):
+                return result
+            }
+        }
+        
+        return nil
+    }
+    
+    /// Iterates over each item of the list in reverse, with enumeration support.
+    func forEachItemReversed<Y, E: Error>(_ borrowingFunction: ((_ index: Int, _ item: borrowing T) throws(E) -> LoopCommand<Y>)) throws(E) -> Y?  {
+        var indexCounter = count
+        var cursor: Node? = self.tail
+        
+        outerLoop: while let nextItem = cursor {
+            let loopIterationResult = try borrowingFunction(indexCounter, nextItem.value)
+            indexCounter -= 1
+            cursor = nextItem.previous
+            switch loopIterationResult {
+            case .loopBreak:
+                break outerLoop
+            case .loopContinue:
+                continue outerLoop
+            case .loopReturn(let result):
+                return result
+            }
+        }
+        
+        return nil
+    }
+    
+    /// Iterates over each item of the list, with enumeration support, updating some value in each iteration and returning the final value at the end.
+    func reduce<Y>(initialResult: Y, _ borrowingFunction: ((_ index: Int, _ partialResult: Y, _ item: borrowing T) throws -> LoopCommand<Y>)) throws -> Y {
+        var indexCounter = 0
+        var currentResult = initialResult
+        
+        var cursor: Node? = self.head
+        
+        outerLoop: while let nextItem = cursor {
+            let loopIterationResult = try borrowingFunction(indexCounter, currentResult, nextItem.value)
+            indexCounter += 1
+            cursor = nextItem.next
+            switch loopIterationResult {
+            case .loopBreak:
+                break outerLoop
+            case .loopContinue:
+                continue outerLoop
+            case .loopReturn(let result):
+                currentResult = result
+                continue outerLoop
+            }
+        }
+        
+        return currentResult
+    }
+    
+    /// Uses a specific item of the list based on a provided index.
+    ///
+    /// O(N/2) worst case scenario
+    ///
+    /// Returns `nil` if nothing was found
+    func useItem<Y>(at index: Int, _ borrowingFunction: ((_ item: borrowing T) throws -> Y)) rethrows -> Y? {
+        if index < 0 || index >= self.count {
+            return nil
+        }
+        else if index < self.count / 2 {
+            return try self.forEachItem({ i, item in
+                if i == index {
+                    return .loopReturn(try borrowingFunction(item))
+                }
+                return .loopContinue
+            })
+        }
+        else {
+            return try self.forEachItemReversed({ i, item in
+                if i == index {
+                    return .loopReturn(try borrowingFunction(item))
+                }
+                return .loopContinue
+            })
+        }
+    }
+    
+    /// Adds an item to the tail end list
+    mutating func add(item: consuming T) {
+        guard self.head != nil, let currentTail = self.tail else {
+            let firstNode = Node(value: item, next: nil, previous: nil)
+            self.head = firstNode
+            self.tail = firstNode
+            self.count = 1
+            return
+        }
+        let newTail = Node(value: item, next: nil, previous: currentTail)
+        currentTail.next = newTail
+        self.tail = newTail
+        self.count += 1
+    }
+    
+    /// A node of the linked list
+    ///
+    /// Should be `~Copyable` but that would require using a value type such as a struct or enum, and the Swift compiler does not support recursive enums with non-copyable objects for some reason. Example:
+    /// ```swift
+    /// enum List<Y: ~Copyable>: ~Copyable {
+    ///     indirect case node(value: Y, next: NewList<Y>)  // <-- ERROR: Noncopyable enum 'List' cannot be marked indirect or have indirect cases yet
+    ///     case empty
+    /// }
+    /// ```
+    ///
+    /// Therefore, we make it `private` to make sure we contain the exposure of this unsafe object to only this class. Outside users of the linked list can access objects via the iterator functions.
+    private class Node<Item: ~Copyable> {
+        let value: Item
+        var next: Node?
+        var previous: Node?
+        
+        init(value: consuming Item, next: consuming Node?, previous: consuming Node?) {
+            self.value = value
+            self.next = next
+            self.previous = previous
+        }
+    }
+
+    /// A loop command to allow closures to control the loop they are in.
+    enum LoopCommand<Y> {
+        /// Breaks out of the loop
+        case loopBreak
+        /// Continues to the next iteration of the loop
+        case loopContinue
+        /// Stops iterating and return a value
+        case loopReturn(Y)
+    }
+}