[Swift] Flexbuffers native swift port (#8577)

* Offical Swift port for FlexBuffers

This is the offical port for FlexBuffers within
swift, and it introcudes a Common Module where code
is shared between flatbuffers and flexbuffers.

Writing most supported values like maps, vectors,
nil and scalars into a flexbuffer buffer. And includes
tests to verify that its similar to cpp

* Reading a flexbuffer

Implementing reading from a flexbuffer, enabling
most of the buffers features, like most types, maps, vectors,
typedvectors, and fixedtypedvectors.

Currently, if an offset/object cant be read we default to a swift
nil instead of the default flexbuffers 'null' with all values.

* Fixes bazel breaking due to new project structure

Address warnings within the library

* Adds comment on why we added the code & properly enforce the amout of bytes needed

swift/Sources/FlatBuffers/ByteBuffer.swift

@@ -293,7 +293,7 @@ public struct ByteBuffer {
     }
     assert(index < _storage.capacity, "Write index is out of writing bound")
     assert(index >= 0, "Writer index should be above zero")
-    _ = withUnsafePointer(to: value) { ptr in
+    withUnsafePointer(to: value) { ptr in
       _storage.withUnsafeRawPointer {
         memcpy(
           $0.advanced(by: index),

swift/Sources/FlatBuffers/Constants.swift

@@ -14,15 +14,11 @@
  * limitations under the License.
  */
 
+#if canImport(Common)
+@_exported import Common
+#endif
 import Foundation
 
-/// A boolean to see if the system is littleEndian
-let isLitteEndian: Bool = {
-  let number: UInt32 = 0x12345678
-  return number == number.littleEndian
-}()
-/// Constant for the file id length
-let FileIdLength = 4
 /// Type aliases
 public typealias Byte = UInt8
 public typealias UOffset = UInt32
@@ -35,80 +31,31 @@ public let FlatBufferMaxSize = UInt32
 /// Protocol that All Scalars should conform to
 ///
 /// Scalar is used to conform all the numbers that can be represented in a FlatBuffer. It's used to write/read from the buffer.
-public protocol Scalar: Equatable {
-  associatedtype NumericValue
-  var convertedEndian: NumericValue { get }
-}
 
-extension Scalar where Self: Verifiable {}
+extension Scalar where Self: FixedWidthInteger {}
 
-extension Scalar where Self: FixedWidthInteger {
-  /// Converts the value from BigEndian to LittleEndian
-  ///
-  /// Converts values to little endian on machines that work with BigEndian, however this is NOT TESTED yet.
-  public var convertedEndian: NumericValue {
-    self as! Self.NumericValue
-  }
-}
+extension Double: Verifiable {}
 
-extension Double: Scalar, Verifiable {
-  public typealias NumericValue = UInt64
+extension Float32: Verifiable {}
 
-  public var convertedEndian: UInt64 {
-    bitPattern.littleEndian
-  }
-}
+extension Bool: Verifiable {}
 
-extension Float32: Scalar, Verifiable {
-  public typealias NumericValue = UInt32
+extension Int: Verifiable {}
 
-  public var convertedEndian: UInt32 {
-    bitPattern.littleEndian
-  }
-}
+extension Int8: Verifiable {}
 
-extension Bool: Scalar, Verifiable {
-  public var convertedEndian: UInt8 {
-    self == true ? 1 : 0
-  }
+extension Int16: Verifiable {}
 
-  public typealias NumericValue = UInt8
-}
+extension Int32: Verifiable {}
 
-extension Int: Scalar, Verifiable {
-  public typealias NumericValue = Int
-}
+extension Int64: Verifiable {}
 
-extension Int8: Scalar, Verifiable {
-  public typealias NumericValue = Int8
-}
+extension UInt8: Verifiable {}
 
-extension Int16: Scalar, Verifiable {
-  public typealias NumericValue = Int16
-}
+extension UInt16: Verifiable {}
 
-extension Int32: Scalar, Verifiable {
-  public typealias NumericValue = Int32
-}
+extension UInt32: Verifiable {}
 
-extension Int64: Scalar, Verifiable {
-  public typealias NumericValue = Int64
-}
-
-extension UInt8: Scalar, Verifiable {
-  public typealias NumericValue = UInt8
-}
-
-extension UInt16: Scalar, Verifiable {
-  public typealias NumericValue = UInt16
-}
-
-extension UInt32: Scalar, Verifiable {
-  public typealias NumericValue = UInt32
-}
-
-extension UInt64: Scalar, Verifiable {
-  public typealias NumericValue = UInt64
-}
+extension UInt64: Verifiable {}
 
 public func FlatBuffersVersion_25_2_10() {}

swift/Sources/FlatBuffers/FlatBufferBuilder.swift

@@ -343,19 +343,6 @@ public struct FlatBufferBuilder {
     }
   }
 
-  /// Gets the padding for the current element
-  /// - Parameters:
-  ///   - bufSize: Current size of the buffer + the offset of the object to be written
-  ///   - elementSize: Element size
-  @inline(__always)
-  @usableFromInline
-  mutating internal func padding(
-    bufSize: UInt32,
-    elementSize: UInt32) -> UInt32
-  {
-    ((~bufSize) &+ 1) & (elementSize &- 1)
-  }
-
   /// Prealigns the buffer before writting a new object into the buffer
   /// - Parameters:
   ///   - len:Length of the object
@@ -364,11 +351,9 @@ public struct FlatBufferBuilder {
   @usableFromInline
   mutating internal func preAlign(len: Int, alignment: Int) {
     minAlignment(size: alignment)
-    _bb.fill(
-      padding: Int(
-        padding(
-          bufSize: _bb.size &+ UOffset(len),
-          elementSize: UOffset(alignment))))
+    _bb.fill(padding: numericCast(padding(
+      bufSize: numericCast(_bb.size) &+ numericCast(len),
+      elementSize: numericCast(alignment))))
   }
 
   /// Prealigns the buffer before writting a new object into the buffer

swift/Sources/FlatBuffers/Int+extension.swift

@@ -1,47 +0,0 @@
-/*
- * Copyright 2024 Google Inc. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-import Foundation
-
-extension Int {
-
-  /// Moves the current int into the nearest power of two
-  ///
-  /// This is used since the UnsafeMutableRawPointer will face issues when writing/reading
-  /// if the buffer alignment exceeds that actual size of the buffer
-  var convertToPowerofTwo: Int {
-    guard self > 0 else { return 1 }
-    var n = UOffset(self)
-
-    #if arch(arm) || arch(i386)
-    let max = UInt32(Int.max)
-    #else
-    let max = UInt32.max
-    #endif
-
-    n -= 1
-    n |= n >> 1
-    n |= n >> 2
-    n |= n >> 4
-    n |= n >> 8
-    n |= n >> 16
-    if n != max {
-      n += 1
-    }
-
-    return Int(n)
-  }
-}

swift/Sources/FlatBuffers/_InternalByteBuffer.swift

@@ -253,7 +253,7 @@ struct _InternalByteBuffer {
     }
     assert(index < _storage.capacity, "Write index is out of writing bound")
     assert(index >= 0, "Writer index should be above zero")
-    _ = withUnsafePointer(to: value) {
+    withUnsafePointer(to: value) {
       memcpy(
         _storage.memory.advanced(by: index),
         $0,