Enables optional enums in swift (#6160)

[Swift] Enables optional enums
2020-10-06 19:00:14 +03:00
parent 5d3cf440e5
commit 5975658ebd
5 changed files with 27 additions and 10 deletions
--- a/src/idl_gen_swift.cpp
+++ b/src/idl_gen_swift.cpp
@@ -520,15 +520,20 @@ class SwiftGenerator : public BaseGenerator {
    if (IsScalar(field.value.type.base_type) &&
        !IsBool(field.value.type.base_type)) {
      std::string is_enum = IsEnum(field.value.type) ? ".rawValue" : "";
+      std::string optional_enum =
+          IsEnum(field.value.type) ? ("?" + is_enum) : "";
      code_ +=
          "{{VALUETYPE}}" + builder_string + "fbb.add(element: {{VALUENAME}}\\";

-      code_ += field.optional ? "\\" : (is_enum + ", def: {{CONSTANT}}\\");
+      code_ += field.optional ? (optional_enum + "\\")
+                              : (is_enum + ", def: {{CONSTANT}}\\");

      code_ += ", at: {{TABLEOFFSET}}.{{OFFSET}}.p) }";

-      auto default_value = IsEnum(field.value.type) ? GenEnumDefaultValue(field)
-                                                    : field.value.constant;
+      auto default_value =
+          IsEnum(field.value.type)
+              ? (field.optional ? "nil" : GenEnumDefaultValue(field))
+              : field.value.constant;
      create_func_header.push_back("" + name + ": " + nullable_type + " = " +
                                   (field.optional ? "nil" : default_value));
      return;
@@ -632,7 +637,7 @@ class SwiftGenerator : public BaseGenerator {
    }

    if (IsEnum(field.value.type)) {
-      auto default_value = GenEnumDefaultValue(field);
+      auto default_value = field.optional ? "nil" : GenEnumDefaultValue(field);
      code_.SetValue("BASEVALUE", GenTypeBasic(field.value.type, false));
      code_ += GenReaderMainBody(optional) + "\\";
      code_ += GenOffset() + "return o == 0 ? " + default_value + " : " +
--- a/tests/FlatBuffers.Test.Swift/SwiftTest.sh
+++ b/tests/FlatBuffers.Test.Swift/SwiftTest.sh
@@ -4,7 +4,7 @@ test_dir=`pwd`

 cd ${swift_dir}/Tests/FlatBuffers.Test.SwiftTests
 ${test_dir}/../flatc --swift --gen-mutable --grpc --gen-object-api -I ${test_dir}/include_test ${test_dir}/monster_test.fbs ${test_dir}/union_vector/union_vector.fbs
-${test_dir}/../flatc --swift ${test_dir}/optional_scalars.fbs
+${test_dir}/../flatc --swift ${test_dir}/optional_scalars2.fbs
 cd ${swift_dir}
 swift build --build-tests
 swift test
--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersTests.swift
@@ -72,14 +72,20 @@ final class FlatBuffersTests: XCTestCase {
                                                                  justI8: 80,
                                                                  maybeI8: nil,
                                                                  justU8: 100,
-                                                                  maybeU8: 10)
+                                                                  maybeU8: 10,
+                                                                  maybeBool: true,
+                                                                  justEnum: .one,
+                                                                  maybeEnum: nil)
        b.finish(offset: root)
        let scalarTable = optional_scalars_ScalarStuff.getRootAsScalarStuff(bb: b.sizedBuffer)
        XCTAssertEqual(scalarTable.justI8, 80)
        XCTAssertNil(scalarTable.maybeI8)
+        XCTAssertEqual(scalarTable.maybeBool, true)
        XCTAssertEqual(scalarTable.defaultI8, 42)
        XCTAssertEqual(scalarTable.justU8, 100)
        XCTAssertEqual(scalarTable.maybeU8, 10)
+        XCTAssertEqual(scalarTable.justEnum, .one)
+        XCTAssertNil(scalarTable.maybeEnum)
    }
 }

--- a/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars2_generated.swift
+++ b/tests/FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests/optional_scalars2_generated.swift
@@ -9,9 +9,10 @@ public enum optional_scalars_OptionalByte: Int8, Enum {
    public var value: Int8 { return self.rawValue }
    case none_ = 0
    case one = 1
+    case two = 2
    

-    public static var max: optional_scalars_OptionalByte { return .one }
+    public static var max: optional_scalars_OptionalByte { return .two }
    public static var min: optional_scalars_OptionalByte { return .none_ }
 }

@@ -62,7 +63,8 @@ public struct optional_scalars_ScalarStuff: FlatBufferObject {
        case maybeBool = 66
        case defaultBool = 68
        case justEnum = 70
-        case defaultEnum = 72
+        case maybeEnum = 72
+        case defaultEnum = 74
        var v: Int32 { Int32(self.rawValue) }
        var p: VOffset { self.rawValue }
    }
@@ -101,8 +103,9 @@ public struct optional_scalars_ScalarStuff: FlatBufferObject {
    public var maybeBool: Bool? { let o = _accessor.offset(VTOFFSET.maybeBool.v); return o == 0 ? true : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
    public var defaultBool: Bool { let o = _accessor.offset(VTOFFSET.defaultBool.v); return o == 0 ? true : 0 != _accessor.readBuffer(of: Byte.self, at: o) }
    public var justEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.justEnum.v); return o == 0 ? .none_ : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .none_ }
+    public var maybeEnum: optional_scalars_OptionalByte? { let o = _accessor.offset(VTOFFSET.maybeEnum.v); return o == 0 ? nil : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? nil }
    public var defaultEnum: optional_scalars_OptionalByte { let o = _accessor.offset(VTOFFSET.defaultEnum.v); return o == 0 ? .one : optional_scalars_OptionalByte(rawValue: _accessor.readBuffer(of: Int8.self, at: o)) ?? .one }
-    public static func startScalarStuff(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 35) }
+    public static func startScalarStuff(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 36) }
    public static func add(justI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justI8, def: 0, at: VTOFFSET.justI8.p) }
    public static func add(maybeI8: Int8?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeI8, at: VTOFFSET.maybeI8.p) }
    public static func add(defaultI8: Int8, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultI8, def: 42, at: VTOFFSET.defaultI8.p) }
@@ -139,6 +142,7 @@ public struct optional_scalars_ScalarStuff: FlatBufferObject {
    public static func add(defaultBool: Bool, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultBool, def: true,
     at: VTOFFSET.defaultBool.p) }
    public static func add(justEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: justEnum.rawValue, def: 0, at: VTOFFSET.justEnum.p) }
+    public static func add(maybeEnum: optional_scalars_OptionalByte?, _ fbb: inout FlatBufferBuilder) { fbb.add(element: maybeEnum?.rawValue, at: VTOFFSET.maybeEnum.p) }
    public static func add(defaultEnum: optional_scalars_OptionalByte, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultEnum.rawValue, def: 1, at: VTOFFSET.defaultEnum.p) }
    public static func endScalarStuff(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset<UOffset> { let end = Offset<UOffset>(offset: fbb.endTable(at: start)); return end }
    public static func createScalarStuff(
@@ -177,6 +181,7 @@ public struct optional_scalars_ScalarStuff: FlatBufferObject {
        maybeBool: Bool? = nil,
        defaultBool: Bool = true,
        justEnum: optional_scalars_OptionalByte = .none_,
+        maybeEnum: optional_scalars_OptionalByte? = nil,
        defaultEnum: optional_scalars_OptionalByte = .one
    ) -> Offset<UOffset> {
        let __start = optional_scalars_ScalarStuff.startScalarStuff(&fbb)
@@ -214,6 +219,7 @@ public struct optional_scalars_ScalarStuff: FlatBufferObject {
        optional_scalars_ScalarStuff.add(maybeBool: maybeBool, &fbb)
        optional_scalars_ScalarStuff.add(defaultBool: defaultBool, &fbb)
        optional_scalars_ScalarStuff.add(justEnum: justEnum, &fbb)
+        optional_scalars_ScalarStuff.add(maybeEnum: maybeEnum, &fbb)
        optional_scalars_ScalarStuff.add(defaultEnum: defaultEnum, &fbb)
        return optional_scalars_ScalarStuff.endScalarStuff(&fbb, start: __start)
    }
--- a/tests/generate_code.sh
+++ b/tests/generate_code.sh
@@ -64,7 +64,7 @@ working_dir=`pwd`
 cd FlatBuffers.Test.Swift/Tests/FlatBuffers.Test.SwiftTests
 $working_dir/../flatc --swift --grpc $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS -I ../../../include_test ../../../monster_test.fbs
 $working_dir/../flatc --swift $TEST_BASE_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS ../../../union_vector/union_vector.fbs
-$working_dir/../flatc --swift ../../../optional_scalars.fbs
+$working_dir/../flatc --swift ../../../optional_scalars2.fbs
 cd $working_dir

 cd FlatBuffers.GRPC.Swift/Sources/Model