[Swift] RFC: Switch Swift namespace from public enum to ordinary concat with _ (#6045)

This PR attempts to switch namespace from public enum back to ordinary concat with _ in Swift. This kept style similar with protobuf, but different from other popular style guide in Swift. This is needed because previously, when we do `public enum`, we don't really know when to declare and when to extend (extension). With namespace implementation in this PR, there is no such ambiguity.
2026-06-12 07:50:59 +00:00 · 2020-07-27 01:06:11 -07:00
parent 18b015d25a
commit 5d052f4e55
7 changed files with 524 additions and 587 deletions
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersMonsterWriterTests.swift
@@ -2,10 +2,10 @@ import XCTest
 import Foundation
@testable import FlatBuffers

-public typealias Test = MyGame.Example.Test
-public typealias Monster = MyGame.Example.Monster
-public typealias Vec3 = MyGame.Example.Vec3
-public typealias Stat = MyGame.Example.Stat
+public typealias Test = MyGame_Example_Test
+public typealias Monster = MyGame_Example_Monster
+public typealias Vec3 = MyGame_Example_Vec3
+public typealias Stat = MyGame_Example_Stat

 class FlatBuffersMonsterWriterTests: XCTestCase {
    
@@ -57,7 +57,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {

    func testCreateMonsterUsingCreateMonsterMethodWithPosX() {
        var fbb = FlatBufferBuilder(initialSize: 1)
-        let pos = MyGame.Example.createVec3(x: 10, test2: .blue)
+        let pos = MyGame_Example_Vec3.createVec3(x: 10, test2: .blue)
        let name = fbb.create(string: "Barney")
        let monster = Monster.createMonster(&fbb, structOfPos: pos, offsetOfName: name)
        fbb.finish(offset: monster)
@@ -68,7 +68,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {

    func testReadMonsterFromUnsafePointerWithoutCopying() {
        var array: [UInt8] = [48, 0, 0, 0, 77, 79, 78, 83, 0, 0, 0, 0, 36, 0, 72, 0, 40, 0, 0, 0, 38, 0, 32, 0, 0, 0, 28, 0, 0, 0, 27, 0, 20, 0, 16, 0, 12, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 36, 0, 0, 0, 164, 0, 0, 0, 0, 0, 0, 1, 60, 0, 0, 0, 68, 0, 0, 0, 76, 0, 0, 0, 0, 0, 0, 1, 88, 0, 0, 0, 120, 0, 0, 0, 0, 0, 80, 0, 0, 0, 128, 63, 0, 0, 0, 64, 0, 0, 64, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 64, 2, 0, 5, 0, 6, 0, 0, 0, 2, 0, 0, 0, 64, 0, 0, 0, 48, 0, 0, 0, 2, 0, 0, 0, 30, 0, 40, 0, 10, 0, 20, 0, 152, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 70, 114, 101, 100, 0, 0, 0, 0, 5, 0, 0, 0, 0, 1, 2, 3, 4, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 50, 0, 0, 0, 5, 0, 0, 0, 116, 101, 115, 116, 49, 0, 0, 0, 9, 0, 0, 0, 77, 121, 77, 111, 110, 115, 116, 101, 114, 0, 0, 0, 3, 0, 0, 0, 20, 0, 0, 0, 36, 0, 0, 0, 4, 0, 0, 0, 240, 255, 255, 255, 32, 0, 0, 0, 248, 255, 255, 255, 36, 0, 0, 0, 12, 0, 8, 0, 0, 0, 0, 0, 0, 0, 4, 0, 12, 0, 0, 0, 28, 0, 0, 0, 5, 0, 0, 0, 87, 105, 108, 109, 97, 0, 0, 0, 6, 0, 0, 0, 66, 97, 114, 110, 101, 121, 0, 0, 5, 0, 0, 0, 70, 114, 111, 100, 111, 0, 0, 0]
-        let unpacked = array.withUnsafeMutableBytes { (memory) -> MyGame.Example.MonsterT in
+        let unpacked = array.withUnsafeMutableBytes { (memory) -> MyGame_Example_MonsterT in
            let bytes = ByteBuffer(assumingMemoryBound: memory.baseAddress!, capacity: memory.count)
            var monster = Monster.getRootAsMonster(bb: bytes)
            readFlatbufferMonster(monster: &monster)
@@ -81,7 +81,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
    func readMonster(fb: ByteBuffer) {
        var monster = Monster.getRootAsMonster(bb: fb)
        readFlatbufferMonster(monster: &monster)
-        var unpacked: MyGame.Example.MonsterT? = monster.unpack()
+        var unpacked: MyGame_Example_MonsterT? = monster.unpack()
        readObjectApi(monster: unpacked!)
        var builder = FlatBufferBuilder()
        let root = Monster.pack(&builder, obj: &unpacked)
@@ -116,13 +116,13 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
        let mon1Start = Monster.startMonster(&fbb)
        Monster.add(name: fred, &fbb)
        let mon2 = Monster.endMonster(&fbb, start: mon1Start)
-        let test4 = fbb.createVector(structs: [MyGame.Example.createTest(a: 30, b: 40),
-                                               MyGame.Example.createTest(a: 10, b: 20)],
+        let test4 = fbb.createVector(structs: [MyGame_Example_Test.createTest(a: 30, b: 40),
+                                               MyGame_Example_Test.createTest(a: 10, b: 20)],
                                     type: Test.self)
        
        let stringTestVector = fbb.createVector(ofOffsets: [test1, test2])

-        let posStruct = MyGame.Example.createVec3(x: 1, y: 2, z: 3, test1: 3, test2: .green, test3a: 5, test3b: 6)
+        let posStruct = MyGame_Example_Vec3.createVec3(x: 1, y: 2, z: 3, test1: 3, test2: .green, test3a: 5, test3b: 6)
        let mStart = Monster.startMonster(&fbb)
        Monster.add(pos: posStruct, &fbb)
        Monster.add(hp: 80, &fbb)
@@ -180,7 +180,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
        XCTAssertTrue(vec?.mutate(test1: 3) ?? false)
    }
    
-    func readFlatbufferMonster(monster: inout MyGame.Example.Monster) {
+    func readFlatbufferMonster(monster: inout MyGame_Example_Monster) {
        XCTAssertEqual(monster.hp, 80)
        XCTAssertEqual(monster.mana, 150)
        XCTAssertEqual(monster.name, "MyMonster")
@@ -233,7 +233,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
        }
    }
    
-    func readObjectApi(monster: MyGame.Example.MonsterT) {
+    func readObjectApi(monster: MyGame_Example_MonsterT) {
        XCTAssertEqual(monster.hp, 80)
        XCTAssertEqual(monster.mana, 150)
        XCTAssertEqual(monster.name, "MyMonster")
@@ -246,7 +246,7 @@ class FlatBuffersMonsterWriterTests: XCTestCase {
        let test = pos?.test3
        XCTAssertEqual(test?.a, 5)
        XCTAssertEqual(test?.b, 6)
-        let monster2 = monster.test?.value as? MyGame.Example.MonsterT
+        let monster2 = monster.test?.value as? MyGame_Example_MonsterT
        XCTAssertEqual(monster2?.name, "Fred")
        XCTAssertEqual(monster.mana, 150)
        monster.mana = 10
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
@@ -62,13 +62,13 @@ final class FlatBuffersTests: XCTestCase {
    
    func testWriteOptionalValues() {
        var b = FlatBufferBuilder()
-        let root = optional_scalars.ScalarStuff.createScalarStuff(&b,
+        let root = optional_scalars_ScalarStuff.createScalarStuff(&b,
                                                                  justI8: 80,
                                                                  maybeI8: nil,
                                                                  justU8: 100,
                                                                  maybeU8: 10)
        b.finish(offset: root)
-        let scalarTable = optional_scalars.ScalarStuff.getRootAsScalarStuff(bb: b.sizedBuffer)
+        let scalarTable = optional_scalars_ScalarStuff.getRootAsScalarStuff(bb: b.sizedBuffer)
        XCTAssertEqual(scalarTable.justI8, 80)
        XCTAssertNil(scalarTable.maybeI8)
        XCTAssertEqual(scalarTable.defaultI8, 42)
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersUnionTests.swift
@@ -82,9 +82,9 @@ final class FlatBuffersUnionTests: XCTestCase {
        
        let characterType: [Character] = [.belle, .mulan, .bookfan]
        let characters = [
-            fb.create(struct: createBookReader(booksRead: 7), type: BookReader.self),
+            fb.create(struct: BookReader.createBookReader(booksRead: 7), type: BookReader.self),
            attack,
-            fb.create(struct: createBookReader(booksRead: 2), type: BookReader.self),
+            fb.create(struct: BookReader.createBookReader(booksRead: 2), type: BookReader.self),
        ]
        let types = fb.createVector(characterType)
        let characterVector = fb.createVector(ofOffsets: characters)
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars_generated.swift
@@ -3,15 +3,13 @@

 import FlatBuffers

-public enum optional_scalars {
-
-public struct ScalarStuff: FlatBufferObject {
+public struct optional_scalars_ScalarStuff: FlatBufferObject {

    static func validateVersion() { FlatBuffersVersion_1_12_0() }
    public var __buffer: ByteBuffer! { return _accessor.bb }
    private var _accessor: Table

-    public static func getRootAsScalarStuff(bb: ByteBuffer) -> ScalarStuff { return ScalarStuff(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }
+    public static func getRootAsScalarStuff(bb: ByteBuffer) -> optional_scalars_ScalarStuff { return optional_scalars_ScalarStuff(Table(bb: bb, position: Int32(bb.read(def: UOffset.self, position: bb.reader)) + Int32(bb.reader))) }

    private init(_ t: Table) { _accessor = t }
    public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) }
@@ -160,46 +158,41 @@ public struct ScalarStuff: FlatBufferObject {
        maybeBool: Bool? = nil,
        defaultBool: Bool = true
    ) -> Offset<UOffset> {
-        let __start = ScalarStuff.startScalarStuff(&fbb)
-        ScalarStuff.add(justI8: justI8, &fbb)
-        ScalarStuff.add(maybeI8: maybeI8, &fbb)
-        ScalarStuff.add(defaultI8: defaultI8, &fbb)
-        ScalarStuff.add(justU8: justU8, &fbb)
-        ScalarStuff.add(maybeU8: maybeU8, &fbb)
-        ScalarStuff.add(defaultU8: defaultU8, &fbb)
-        ScalarStuff.add(justI16: justI16, &fbb)
-        ScalarStuff.add(maybeI16: maybeI16, &fbb)
-        ScalarStuff.add(defaultI16: defaultI16, &fbb)
-        ScalarStuff.add(justU16: justU16, &fbb)
-        ScalarStuff.add(maybeU16: maybeU16, &fbb)
-        ScalarStuff.add(defaultU16: defaultU16, &fbb)
-        ScalarStuff.add(justI32: justI32, &fbb)
-        ScalarStuff.add(maybeI32: maybeI32, &fbb)
-        ScalarStuff.add(defaultI32: defaultI32, &fbb)
-        ScalarStuff.add(justU32: justU32, &fbb)
-        ScalarStuff.add(maybeU32: maybeU32, &fbb)
-        ScalarStuff.add(defaultU32: defaultU32, &fbb)
-        ScalarStuff.add(justI64: justI64, &fbb)
-        ScalarStuff.add(maybeI64: maybeI64, &fbb)
-        ScalarStuff.add(defaultI64: defaultI64, &fbb)
-        ScalarStuff.add(justU64: justU64, &fbb)
-        ScalarStuff.add(maybeU64: maybeU64, &fbb)
-        ScalarStuff.add(defaultU64: defaultU64, &fbb)
-        ScalarStuff.add(justF32: justF32, &fbb)
-        ScalarStuff.add(maybeF32: maybeF32, &fbb)
-        ScalarStuff.add(defaultF32: defaultF32, &fbb)
-        ScalarStuff.add(justF64: justF64, &fbb)
-        ScalarStuff.add(maybeF64: maybeF64, &fbb)
-        ScalarStuff.add(defaultF64: defaultF64, &fbb)
-        ScalarStuff.add(justBool: justBool, &fbb)
-        ScalarStuff.add(maybeBool: maybeBool, &fbb)
-        ScalarStuff.add(defaultBool: defaultBool, &fbb)
-        return ScalarStuff.endScalarStuff(&fbb, start: __start)
+        let __start = optional_scalars_ScalarStuff.startScalarStuff(&fbb)
+        optional_scalars_ScalarStuff.add(justI8: justI8, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI8: maybeI8, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI8: defaultI8, &fbb)
+        optional_scalars_ScalarStuff.add(justU8: justU8, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU8: maybeU8, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU8: defaultU8, &fbb)
+        optional_scalars_ScalarStuff.add(justI16: justI16, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI16: maybeI16, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI16: defaultI16, &fbb)
+        optional_scalars_ScalarStuff.add(justU16: justU16, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU16: maybeU16, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU16: defaultU16, &fbb)
+        optional_scalars_ScalarStuff.add(justI32: justI32, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI32: maybeI32, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI32: defaultI32, &fbb)
+        optional_scalars_ScalarStuff.add(justU32: justU32, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU32: maybeU32, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU32: defaultU32, &fbb)
+        optional_scalars_ScalarStuff.add(justI64: justI64, &fbb)
+        optional_scalars_ScalarStuff.add(maybeI64: maybeI64, &fbb)
+        optional_scalars_ScalarStuff.add(defaultI64: defaultI64, &fbb)
+        optional_scalars_ScalarStuff.add(justU64: justU64, &fbb)
+        optional_scalars_ScalarStuff.add(maybeU64: maybeU64, &fbb)
+        optional_scalars_ScalarStuff.add(defaultU64: defaultU64, &fbb)
+        optional_scalars_ScalarStuff.add(justF32: justF32, &fbb)
+        optional_scalars_ScalarStuff.add(maybeF32: maybeF32, &fbb)
+        optional_scalars_ScalarStuff.add(defaultF32: defaultF32, &fbb)
+        optional_scalars_ScalarStuff.add(justF64: justF64, &fbb)
+        optional_scalars_ScalarStuff.add(maybeF64: maybeF64, &fbb)
+        optional_scalars_ScalarStuff.add(defaultF64: defaultF64, &fbb)
+        optional_scalars_ScalarStuff.add(justBool: justBool, &fbb)
+        optional_scalars_ScalarStuff.add(maybeBool: maybeBool, &fbb)
+        optional_scalars_ScalarStuff.add(defaultBool: defaultBool, &fbb)
+        return optional_scalars_ScalarStuff.endScalarStuff(&fbb, start: __start)
    }
 }

-}
-
-// MARK: - optional_scalars
-
-
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/union_vector_generated.swift
@@ -125,18 +125,24 @@ public class BookReaderT: NativeTable {
    }

 }
-public func createRapunzel(hairLength: Int32 = 0) -> UnsafeMutableRawPointer {
-    let memory = UnsafeMutableRawPointer.allocate(byteCount: Rapunzel.size, alignment: Rapunzel.alignment)
-    memory.initializeMemory(as: UInt8.self, repeating: 0, count: Rapunzel.size)
-    memory.storeBytes(of: hairLength, toByteOffset: 0, as: Int32.self)
-    return memory
+extension Rapunzel {
+    public static func createRapunzel(hairLength: Int32 = 0) -> UnsafeMutableRawPointer {
+        let memory = UnsafeMutableRawPointer.allocate(byteCount: Rapunzel.size, alignment: Rapunzel.alignment)
+        memory.initializeMemory(as: UInt8.self, repeating: 0, count: Rapunzel.size)
+        memory.storeBytes(of: hairLength, toByteOffset: 0, as: Int32.self)
+        return memory
+    }
+
 }

-public func createBookReader(booksRead: Int32 = 0) -> UnsafeMutableRawPointer {
-    let memory = UnsafeMutableRawPointer.allocate(byteCount: BookReader.size, alignment: BookReader.alignment)
-    memory.initializeMemory(as: UInt8.self, repeating: 0, count: BookReader.size)
-    memory.storeBytes(of: booksRead, toByteOffset: 0, as: Int32.self)
-    return memory
+extension BookReader {
+    public static func createBookReader(booksRead: Int32 = 0) -> UnsafeMutableRawPointer {
+        let memory = UnsafeMutableRawPointer.allocate(byteCount: BookReader.size, alignment: BookReader.alignment)
+        memory.initializeMemory(as: UInt8.self, repeating: 0, count: BookReader.size)
+        memory.storeBytes(of: booksRead, toByteOffset: 0, as: Int32.self)
+        return memory
+    }
+
 }

 public struct Attacker: FlatBufferObject {