data identical

Author: vanvoorden

Sources/FoundationEssentials/Data/Data.swift

@@ -2974,3 +2974,103 @@ extension Data : Codable {
         }
     }
 }
+
+// TODO: remove once _overrideLifetime is public in the standard library
+/// Unsafely discard any lifetime dependency on the `dependent` argument. Return
+/// a value identical to `dependent` with a lifetime dependency on the caller's
+/// borrow scope of the `source` argument.
+@unsafe
+@_unsafeNonescapableResult
+@_alwaysEmitIntoClient
+@_transparent
+@lifetime(borrow source)
+internal func _overrideLifetime<
+  T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable
+>(
+  _ dependent: consuming T, borrowing source: borrowing U
+) -> T {
+  dependent
+}
+
+/// Unsafely discard any lifetime dependency on the `dependent` argument. Return
+/// a value identical to `dependent` that inherits all lifetime dependencies from
+/// the `source` argument.
+@unsafe
+@_unsafeNonescapableResult
+@_alwaysEmitIntoClient
+@_transparent
+@lifetime(copy source)
+internal func _overrideLifetime<
+  T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable
+>(
+  _ dependent: consuming T, copying source: borrowing U
+) -> T {
+  dependent
+}
+
+/// Unsafely discard any lifetime dependency on the `dependent` argument.
+/// Return a value identical to `dependent` with a lifetime dependency
+/// on the caller's exclusive borrow scope of the `source` argument.
+@unsafe
+@_unsafeNonescapableResult
+@_alwaysEmitIntoClient
+@_transparent
+@lifetime(&source)
+internal func _overrideLifetime<
+  T: ~Copyable & ~Escapable, U: ~Copyable & ~Escapable
+>(
+  _ dependent: consuming T,
+  mutating source: inout U
+) -> T {
+  dependent
+}
+
+extension Data {
+  /// Returns a boolean value indicating whether this data is identical to
+  /// `other`.
+  ///
+  /// Two data values are identical if there is no way to distinguish between
+  /// them.
+  ///
+  /// Comparing data this way includes comparing (normally) hidden
+  /// implementation details such as the memory location of any underlying
+  /// data storage object. Therefore, identical data are guaranteed to
+  /// compare equal with `==`, but not all equal data are considered
+  /// identical.
+  ///
+  /// - Performance: O(1)
+  @_alwaysEmitIntoClient
+  public func isIdentical(to other: Self) -> Bool {
+    // See if both are empty
+    switch (self._representation, other._representation) {
+    case (.empty, .empty):
+        return true
+    case (.inline, .inline), (.slice, .slice), (.large, .large):
+        // Continue on to checks below
+        break
+    default:
+        return false
+    }
+
+    let length1 = self.count
+    let length2 = other.count
+
+    // Unequal length data can never be equal
+    guard length1 == length2 else {
+        return false
+    }
+    
+    if length1 > 0 {
+        return self.withUnsafeBytes { (b1: UnsafeRawBufferPointer) in
+            return other.withUnsafeBytes { (b2: UnsafeRawBufferPointer) in
+                // If they have the same base address and same count, it is equal
+                let b1Address = b1.baseAddress!
+                let b2Address = b2.baseAddress!
+                
+                return b1Address == b2Address
+            }
+        }
+    }
+    return true
+  }
+}