diff --git a/scripts/generate_code.py b/scripts/generate_code.py index dd84cfdfb..66e978517 100755 --- a/scripts/generate_code.py +++ b/scripts/generate_code.py @@ -432,6 +432,7 @@ flatc( ) flatc(SWIFT_OPTS, schema="optional_scalars.fbs", prefix=swift_prefix) flatc(SWIFT_OPTS, schema="vector_has_test.fbs", prefix=swift_prefix) +flatc(SWIFT_OPTS, schema="nan_inf_test.fbs", prefix=swift_prefix) flatc( SWIFT_OPTS + ["--gen-object-api"], schema="more_defaults.fbs", diff --git a/src/idl_gen_swift.cpp b/src/idl_gen_swift.cpp index c7cf2b5c8..0424f7db8 100644 --- a/src/idl_gen_swift.cpp +++ b/src/idl_gen_swift.cpp @@ -258,11 +258,9 @@ class SwiftGenerator : public BaseGenerator { IsEnum(field.value.type) ? "{{BASEVALUE}}" : "{{VALUETYPE}}"; code_ += "private var _{{FIELDVAR}}: " + valueType; const auto accessing_value = IsEnum(field.value.type) ? ".value" : ""; - const auto is_bool = IsBool(field.value.type.base_type); const auto base_value = IsStruct(field.value.type) ? (type + "()") - : is_bool ? ("0" == field.value.constant ? "false" : "true") - : field.value.constant; + : SwiftConstant(field); main_constructor.push_back("_" + field_var + " = " + field_var + accessing_value); @@ -378,35 +376,6 @@ class SwiftGenerator : public BaseGenerator { code_ += "}\n"; } - // Generates the create function for swift - void GenStructWriter(const StructDef &struct_def) { - const bool is_private_access = - parser_.opts.swift_implementation_only || - struct_def.attributes.Lookup("private") != nullptr; - code_.SetValue("ACCESS_TYPE", is_private_access ? "internal" : "public"); - code_.SetValue("STRUCTNAME", namer_.NamespacedType(struct_def)); - code_.SetValue("SHORT_STRUCTNAME", namer_.Method(struct_def)); - code_ += "extension {{STRUCTNAME}} {"; - Indent(); - code_ += "@discardableResult"; - code_ += - "{{ACCESS_TYPE}} static func create{{SHORT_STRUCTNAME}}(builder: inout " - "FlatBufferBuilder, \\"; - std::string func_header = ""; - GenerateStructArgs(struct_def, &func_header, "", ""); - code_ += func_header.substr(0, func_header.size() - 2) + "\\"; - code_ += ") -> Offset {"; - Indent(); - code_ += - "builder.createStructOf(size: {{STRUCTNAME}}.size, alignment: " - "{{STRUCTNAME}}.alignment)"; - code_ += "return builder.endStruct()"; - Outdent(); - code_ += "}\n"; - Outdent(); - code_ += "}\n"; - } - void GenerateStructArgs(const StructDef &struct_def, std::string *code_ptr, const std::string &nameprefix, const std::string &object_name, @@ -430,11 +399,7 @@ class SwiftGenerator : public BaseGenerator { code += nameprefix + field_var + ": " + type; if (!IsEnum(field.value.type)) { code += " = "; - const auto is_bool = IsBool(field.value.type.base_type); - const auto constant = - is_bool ? ("0" == field.value.constant ? "false" : "true") - : field.value.constant; - code += constant; + code += SwiftConstant(field); } code += ", "; continue; @@ -633,7 +598,7 @@ class SwiftGenerator : public BaseGenerator { code_.SetValue("FIELDVAR", namer_.Variable(field)); code_.SetValue("VALUETYPE", nullable_type); code_.SetValue("OFFSET", namer_.Field(field)); - code_.SetValue("CONSTANT", field.value.constant); + code_.SetValue("CONSTANT", SwiftConstant(field)); std::string check_if_vector = (IsVector(field.value.type) || IsArray(field.value.type)) ? "VectorOf(" : "("; @@ -659,7 +624,7 @@ class SwiftGenerator : public BaseGenerator { const auto default_value = IsEnum(field.value.type) ? (field.IsOptional() ? "nil" : GenEnumDefaultValue(field)) - : field.value.constant; + : SwiftConstant(field); create_func_header.push_back( "" + field_field + ": " + nullable_type + " = " + (field.IsOptional() ? "nil" : default_value)); @@ -667,8 +632,7 @@ class SwiftGenerator : public BaseGenerator { } if (IsBool(field.value.type.base_type)) { - std::string default_value = - "0" == field.value.constant ? "false" : "true"; + std::string default_value = SwiftConstant(field); code_.SetValue("CONSTANT", default_value); code_.SetValue("VALUETYPE", field.IsOptional() ? "Bool?" : "Bool"); @@ -743,7 +707,7 @@ class SwiftGenerator : public BaseGenerator { code_.SetValue("FIELDMETHOD", namer_.Method(field)); code_.SetValue("VALUETYPE", type); code_.SetValue("OFFSET", namer_.Constant(field.name)); - code_.SetValue("CONSTANT", field.value.constant); + code_.SetValue("CONSTANT", SwiftConstant(field)); bool opt_scalar = field.IsOptional() && IsScalar(field.value.type.base_type); std::string def_Val = opt_scalar ? "nil" : "{{CONSTANT}}"; @@ -761,7 +725,7 @@ class SwiftGenerator : public BaseGenerator { if (IsBool(field.value.type.base_type)) { std::string default_value = field.IsOptional() ? "nil" - : ("0" == field.value.constant ? "false" : "true"); + : SwiftConstant(field); code_.SetValue("CONSTANT", default_value); code_.SetValue("VALUETYPE", "Bool"); code_ += GenReaderMainBody(optional) + "\\"; @@ -809,7 +773,7 @@ class SwiftGenerator : public BaseGenerator { break; case BASE_TYPE_STRING: { - const auto default_string = "\"" + field.value.constant + "\""; + const auto default_string = "\"" + SwiftConstant(field) + "\""; code_.SetValue("VALUETYPE", GenType(field.value.type)); code_.SetValue("CONSTANT", field.IsDefault() ? default_string : "nil"); code_ += GenReaderMainBody(is_required) + GenOffset() + @@ -1017,20 +981,20 @@ class SwiftGenerator : public BaseGenerator { field.value.type.VectorType().base_type != BASE_TYPE_UTYPE; code_.SetValue("FIELDVAR", namer_.Variable(field)); - code_.SetValue("CONSTANT", field.value.constant); + code_.SetValue("CONSTANT", SwiftConstant(field)); bool should_indent = true; if (is_non_union_vector) { code_ += "if {{FIELDVAR}}Count > 0 {"; } else if (IsEnum(type) && !field.IsOptional()) { code_.SetValue("CONSTANT", GenEnumDefaultValue(field)); code_ += "if {{FIELDVAR}} != {{CONSTANT}} {"; + } else if (IsFloat(type.base_type) && StringIsFlatbufferNan(field.value.constant)) { + code_ += "if !{{FIELDVAR}}.isNaN {"; } else if (IsScalar(type.base_type) && !IsEnum(type) && !IsBool(type.base_type) && !field.IsOptional()) { code_ += "if {{FIELDVAR}} != {{CONSTANT}} {"; } else if (IsBool(type.base_type) && !field.IsOptional()) { - std::string default_value = - "0" == field.value.constant ? "false" : "true"; - code_.SetValue("CONSTANT", default_value); + code_.SetValue("CONSTANT", SwiftConstant(field)); code_ += "if {{FIELDVAR}} != {{CONSTANT}} {"; } else { should_indent = false; @@ -1578,13 +1542,13 @@ class SwiftGenerator : public BaseGenerator { if (field.IsRequired()) { std::string default_value = - field.IsDefault() ? field.value.constant : ""; + field.IsDefault() ? SwiftConstant(field) : ""; base_constructor.push_back(field_var + " = \"" + default_value + "\""); break; } if (field.IsDefault() && !field.IsRequired()) { - std::string value = field.IsDefault() ? field.value.constant : "nil"; + std::string value = field.IsDefault() ? SwiftConstant(field) : "nil"; base_constructor.push_back(field_var + " = \"" + value + "\""); } break; @@ -1603,14 +1567,14 @@ class SwiftGenerator : public BaseGenerator { code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}: {{VALUETYPE}}" + nullable; if (!field.IsOptional()) base_constructor.push_back(field_var + " = " + - field.value.constant); + SwiftConstant(field)); break; } if (IsEnum(field.value.type)) { const auto default_value = IsEnum(field.value.type) ? GenEnumDefaultValue(field) - : field.value.constant; + : SwiftConstant(field); code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}: {{VALUETYPE}}"; base_constructor.push_back(field_var + " = " + default_value); break; @@ -1618,10 +1582,8 @@ class SwiftGenerator : public BaseGenerator { if (IsBool(field.value.type.base_type)) { code_ += "{{ACCESS_TYPE}} var {{FIELDVAR}}: Bool" + nullable; - std::string default_value = - "0" == field.value.constant ? "false" : "true"; if (!field.IsOptional()) - base_constructor.push_back(field_var + " = " + default_value); + base_constructor.push_back(field_var + " = " + SwiftConstant(field)); } } } @@ -1676,7 +1638,7 @@ class SwiftGenerator : public BaseGenerator { if (IsEnum(vectortype) && vectortype.base_type != BASE_TYPE_UNION) { const auto default_value = IsEnum(field.value.type) ? GenEnumDefaultValue(field) - : field.value.constant; + : SwiftConstant(field); buffer_constructor.push_back(indentation + field_var + ".append(_t." + field_field + "(at: index)!)"); break; @@ -1869,6 +1831,16 @@ class SwiftGenerator : public BaseGenerator { } } + std::string SwiftConstant(const FieldDef& field) { + const auto default_value = + StringIsFlatbufferNan(field.value.constant) ? ".nan" : + StringIsFlatbufferPositiveInfinity(field.value.constant) ? ".infinity" : + StringIsFlatbufferNegativeInfinity(field.value.constant) ? "-.infinity" : + IsBool(field.value.type.base_type) ? ("0" == field.value.constant ? "false" : "true") : + field.value.constant; + return default_value; + } + std::string GenEnumConstructor(const std::string &at) { return "{{VALUETYPE}}(rawValue: " + GenReader("BASEVALUE", at) + ") "; } diff --git a/tests/nan_inf_test.fbs b/tests/nan_inf_test.fbs new file mode 100644 index 000000000..e9dc281d7 --- /dev/null +++ b/tests/nan_inf_test.fbs @@ -0,0 +1,14 @@ +namespace Swift.Tests; + +table NanInfTable +{ + default_nan:double = nan; + default_inf:double = inf; + default_ninf:double = -inf; + value_nan:double; + value_inf:double; + value_ninf:double; + value:double; +} + +root_type NanInfTable; diff --git a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift index ef7d697a8..192406873 100644 --- a/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift +++ b/tests/swift/Wasm.tests/Tests/FlatBuffers.Test.Swift.WasmTests/monster_test_generated.swift @@ -1184,6 +1184,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac case nativeInline = 106 case longEnumNonEnumDefault = 108 case longEnumNormalDefault = 110 + case nanDefault = 112 + case infDefault = 114 + case positiveInfDefault = 116 + case infinityDefault = 118 + case positiveInfinityDefault = 120 + case negativeInfDefault = 122 + case negativeInfinityDefault = 124 + case doubleInfDefault = 126 var v: Int32 { Int32(self.rawValue) } var p: VOffset { self.rawValue } } @@ -1334,7 +1342,23 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac @discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v); return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) } public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone } @discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) } - public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 54) } + public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? .nan : _accessor.readBuffer(of: Float32.self, at: o) } + @discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.nanDefault.v); return _accessor.mutate(nanDefault, index: o) } + public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) } + @discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infDefault.v); return _accessor.mutate(infDefault, index: o) } + public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) } + @discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return _accessor.mutate(positiveInfDefault, index: o) } + public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) } + @discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infinityDefault.v); return _accessor.mutate(infinityDefault, index: o) } + public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Float32.self, at: o) } + @discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return _accessor.mutate(positiveInfinityDefault, index: o) } + public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) } + @discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return _accessor.mutate(negativeInfDefault, index: o) } + public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) } + @discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return _accessor.mutate(negativeInfinityDefault, index: o) } + public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? +.infinity : _accessor.readBuffer(of: Double.self, at: o) } + @discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return _accessor.mutate(doubleInfDefault, index: o) } + public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) } public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) } public static func add(mana: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: mana, def: 150, at: VTOFFSET.mana.p) } public static func add(hp: Int16, _ fbb: inout FlatBufferBuilder) { fbb.add(element: hp, def: 100, at: VTOFFSET.hp.p) } @@ -1398,6 +1422,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) } public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) } public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) } + public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: .nan, at: VTOFFSET.nanDefault.p) } + public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: +.infinity, at: VTOFFSET.infDefault.p) } + public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: +.infinity, at: VTOFFSET.positiveInfDefault.p) } + public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: +.infinity, at: VTOFFSET.infinityDefault.p) } + public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: +.infinity, at: VTOFFSET.positiveInfinityDefault.p) } + public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -.infinity, at: VTOFFSET.negativeInfDefault.p) } + public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -.infinity, at: VTOFFSET.negativeInfinityDefault.p) } + public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: +.infinity, at: VTOFFSET.doubleInfDefault.p) } public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end } public static func createMonster( _ fbb: inout FlatBufferBuilder, @@ -1453,7 +1485,15 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac scalarKeySortedTablesVectorOffset scalarKeySortedTables: Offset = Offset(), nativeInline: MyGame_Example_Test? = nil, longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone, - longEnumNormalDefault: MyGame_Example_LongEnum = .longone + longEnumNormalDefault: MyGame_Example_LongEnum = .longone, + nanDefault: Float32 = .nan, + infDefault: Float32 = +.infinity, + positiveInfDefault: Float32 = +.infinity, + infinityDefault: Float32 = +.infinity, + positiveInfinityDefault: Float32 = +.infinity, + negativeInfDefault: Float32 = -.infinity, + negativeInfinityDefault: Float32 = -.infinity, + doubleInfDefault: Double = +.infinity ) -> Offset { let __start = MyGame_Example_Monster.startMonster(&fbb) MyGame_Example_Monster.add(pos: pos, &fbb) @@ -1509,6 +1549,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac MyGame_Example_Monster.add(nativeInline: nativeInline, &fbb) MyGame_Example_Monster.add(longEnumNonEnumDefault: longEnumNonEnumDefault, &fbb) MyGame_Example_Monster.add(longEnumNormalDefault: longEnumNormalDefault, &fbb) + MyGame_Example_Monster.add(nanDefault: nanDefault, &fbb) + MyGame_Example_Monster.add(infDefault: infDefault, &fbb) + MyGame_Example_Monster.add(positiveInfDefault: positiveInfDefault, &fbb) + MyGame_Example_Monster.add(infinityDefault: infinityDefault, &fbb) + MyGame_Example_Monster.add(positiveInfinityDefault: positiveInfinityDefault, &fbb) + MyGame_Example_Monster.add(negativeInfDefault: negativeInfDefault, &fbb) + MyGame_Example_Monster.add(negativeInfinityDefault: negativeInfinityDefault, &fbb) + MyGame_Example_Monster.add(doubleInfDefault: doubleInfDefault, &fbb) return MyGame_Example_Monster.endMonster(&fbb, start: __start) } public static func sortVectorOfMonster(offsets:[Offset], _ fbb: inout FlatBufferBuilder) -> Offset { @@ -1668,6 +1716,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac MyGame_Example_Monster.add(nativeInline: obj.nativeInline, &builder) MyGame_Example_Monster.add(longEnumNonEnumDefault: obj.longEnumNonEnumDefault, &builder) MyGame_Example_Monster.add(longEnumNormalDefault: obj.longEnumNormalDefault, &builder) + MyGame_Example_Monster.add(nanDefault: obj.nanDefault, &builder) + MyGame_Example_Monster.add(infDefault: obj.infDefault, &builder) + MyGame_Example_Monster.add(positiveInfDefault: obj.positiveInfDefault, &builder) + MyGame_Example_Monster.add(infinityDefault: obj.infinityDefault, &builder) + MyGame_Example_Monster.add(positiveInfinityDefault: obj.positiveInfinityDefault, &builder) + MyGame_Example_Monster.add(negativeInfDefault: obj.negativeInfDefault, &builder) + MyGame_Example_Monster.add(negativeInfinityDefault: obj.negativeInfinityDefault, &builder) + MyGame_Example_Monster.add(doubleInfDefault: obj.doubleInfDefault, &builder) return MyGame_Example_Monster.endMonster(&builder, start: __root) } @@ -1756,6 +1812,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac try _v.visit(field: VTOFFSET.nativeInline.p, fieldName: "nativeInline", required: false, type: MyGame_Example_Test.self) try _v.visit(field: VTOFFSET.longEnumNonEnumDefault.p, fieldName: "longEnumNonEnumDefault", required: false, type: MyGame_Example_LongEnum.self) try _v.visit(field: VTOFFSET.longEnumNormalDefault.p, fieldName: "longEnumNormalDefault", required: false, type: MyGame_Example_LongEnum.self) + try _v.visit(field: VTOFFSET.nanDefault.p, fieldName: "nanDefault", required: false, type: Float32.self) + try _v.visit(field: VTOFFSET.infDefault.p, fieldName: "infDefault", required: false, type: Float32.self) + try _v.visit(field: VTOFFSET.positiveInfDefault.p, fieldName: "positiveInfDefault", required: false, type: Float32.self) + try _v.visit(field: VTOFFSET.infinityDefault.p, fieldName: "infinityDefault", required: false, type: Float32.self) + try _v.visit(field: VTOFFSET.positiveInfinityDefault.p, fieldName: "positiveInfinityDefault", required: false, type: Float32.self) + try _v.visit(field: VTOFFSET.negativeInfDefault.p, fieldName: "negativeInfDefault", required: false, type: Float32.self) + try _v.visit(field: VTOFFSET.negativeInfinityDefault.p, fieldName: "negativeInfinityDefault", required: false, type: Float32.self) + try _v.visit(field: VTOFFSET.doubleInfDefault.p, fieldName: "doubleInfDefault", required: false, type: Double.self) _v.finish() } } @@ -1816,6 +1880,14 @@ extension MyGame_Example_Monster: Encodable { case nativeInline = "native_inline" case longEnumNonEnumDefault = "long_enum_non_enum_default" case longEnumNormalDefault = "long_enum_normal_default" + case nanDefault = "nan_default" + case infDefault = "inf_default" + case positiveInfDefault = "positive_inf_default" + case infinityDefault = "infinity_default" + case positiveInfinityDefault = "positive_infinity_default" + case negativeInfDefault = "negative_inf_default" + case negativeInfinityDefault = "negative_infinity_default" + case doubleInfDefault = "double_inf_default" } public func encode(to encoder: Encoder) throws { var container = encoder.container(keyedBy: CodingKeys.self) @@ -2033,6 +2105,30 @@ extension MyGame_Example_Monster: Encodable { if longEnumNormalDefault != .longone { try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault) } + if !nanDefault.isNaN { + try container.encodeIfPresent(nanDefault, forKey: .nanDefault) + } + if infDefault != +.infinity { + try container.encodeIfPresent(infDefault, forKey: .infDefault) + } + if positiveInfDefault != +.infinity { + try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault) + } + if infinityDefault != +.infinity { + try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault) + } + if positiveInfinityDefault != +.infinity { + try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault) + } + if negativeInfDefault != -.infinity { + try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault) + } + if negativeInfinityDefault != -.infinity { + try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault) + } + if doubleInfDefault != +.infinity { + try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault) + } } } @@ -2088,6 +2184,14 @@ public class MyGame_Example_MonsterT: NativeObject { public var nativeInline: MyGame_Example_Test? public var longEnumNonEnumDefault: MyGame_Example_LongEnum public var longEnumNormalDefault: MyGame_Example_LongEnum + public var nanDefault: Float32 + public var infDefault: Float32 + public var positiveInfDefault: Float32 + public var infinityDefault: Float32 + public var positiveInfinityDefault: Float32 + public var negativeInfDefault: Float32 + public var negativeInfinityDefault: Float32 + public var doubleInfDefault: Double public init(_ _t: inout MyGame_Example_Monster) { pos = _t.pos @@ -2240,6 +2344,14 @@ public class MyGame_Example_MonsterT: NativeObject { nativeInline = _t.nativeInline longEnumNonEnumDefault = _t.longEnumNonEnumDefault longEnumNormalDefault = _t.longEnumNormalDefault + nanDefault = _t.nanDefault + infDefault = _t.infDefault + positiveInfDefault = _t.positiveInfDefault + infinityDefault = _t.infinityDefault + positiveInfinityDefault = _t.positiveInfinityDefault + negativeInfDefault = _t.negativeInfDefault + negativeInfinityDefault = _t.negativeInfinityDefault + doubleInfDefault = _t.doubleInfDefault } public init() { @@ -2290,6 +2402,14 @@ public class MyGame_Example_MonsterT: NativeObject { nativeInline = MyGame_Example_Test() longEnumNonEnumDefault = .longone longEnumNormalDefault = .longone + nanDefault = .nan + infDefault = +.infinity + positiveInfDefault = +.infinity + infinityDefault = +.infinity + positiveInfinityDefault = +.infinity + negativeInfDefault = -.infinity + negativeInfinityDefault = -.infinity + doubleInfDefault = +.infinity } public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) } diff --git a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersNanInfTests.swift b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersNanInfTests.swift new file mode 100644 index 000000000..e6ee5a5ab --- /dev/null +++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersNanInfTests.swift @@ -0,0 +1,68 @@ +/* + * Copyright 2022 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 XCTest +@testable import FlatBuffers + +final class FlatBuffersNanInfTests: XCTestCase { + + func createTestTable() -> FlatBufferBuilder { + var fbb = FlatBufferBuilder() + let msg = Swift_Tests_NanInfTable.createNanInfTable(&fbb, + valueNan: .nan, + valueInf: .infinity, + valueNinf: -.infinity, + value: 100.0 + ) + fbb.finish(offset: msg) + return fbb + } + + func testInfNanBinary() { + let fbb = createTestTable() + let data = fbb.sizedByteArray + + let table = Swift_Tests_NanInfTable.getRootAsNanInfTable(bb: ByteBuffer(bytes: data)) + XCTAssert(table.defaultNan.isNaN) + XCTAssertEqual(table.defaultInf, .infinity) + XCTAssertEqual(table.defaultNinf, -.infinity) + XCTAssert(table.valueNan.isNaN) + XCTAssertEqual(table.valueInf, .infinity) + XCTAssertEqual(table.valueNinf, -.infinity) + XCTAssertEqual(table.value, 100.0) + } + + func testInfNanJSON() { + let fbb = createTestTable() + var bb = fbb.sizedBuffer + do { + let reader: Swift_Tests_NanInfTable = try getCheckedRoot(byteBuffer: &bb) + let encoder = JSONEncoder() + encoder.keyEncodingStrategy = .convertToSnakeCase + encoder.nonConformingFloatEncodingStrategy = + .convertToString(positiveInfinity: "inf", negativeInfinity: "-inf", nan: "nan") + let data = try encoder.encode(reader) + XCTAssertEqual(data, jsonData.data(using: .utf8)) + } catch { + XCTFail(error.localizedDescription) + } + } + + var jsonData: String { + "{\"value_inf\":\"inf\",\"value\":100,\"value_nan\":\"nan\",\"value_ninf\":\"-inf\"}" + } + +} diff --git a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift index 18d227f92..67399e1c7 100644 --- a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift +++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift @@ -1342,21 +1342,21 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac @discardableResult public func mutate(longEnumNonEnumDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNonEnumDefault.v); return _accessor.mutate(longEnumNonEnumDefault.rawValue, index: o) } public var longEnumNormalDefault: MyGame_Example_LongEnum { let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return o == 0 ? .longone : MyGame_Example_LongEnum(rawValue: _accessor.readBuffer(of: UInt64.self, at: o)) ?? .longone } @discardableResult public func mutate(longEnumNormalDefault: MyGame_Example_LongEnum) -> Bool {let o = _accessor.offset(VTOFFSET.longEnumNormalDefault.v); return _accessor.mutate(longEnumNormalDefault.rawValue, index: o) } - public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? nan : _accessor.readBuffer(of: Float32.self, at: o) } + public var nanDefault: Float32 { let o = _accessor.offset(VTOFFSET.nanDefault.v); return o == 0 ? .nan : _accessor.readBuffer(of: Float32.self, at: o) } @discardableResult public func mutate(nanDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.nanDefault.v); return _accessor.mutate(nanDefault, index: o) } - public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Float32.self, at: o) } + public var infDefault: Float32 { let o = _accessor.offset(VTOFFSET.infDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) } @discardableResult public func mutate(infDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infDefault.v); return _accessor.mutate(infDefault, index: o) } - public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? +inf : _accessor.readBuffer(of: Float32.self, at: o) } + public var positiveInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) } @discardableResult public func mutate(positiveInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfDefault.v); return _accessor.mutate(positiveInfDefault, index: o) } - public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? infinity : _accessor.readBuffer(of: Float32.self, at: o) } + public var infinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.infinityDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) } @discardableResult public func mutate(infinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.infinityDefault.v); return _accessor.mutate(infinityDefault, index: o) } - public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? +infinity : _accessor.readBuffer(of: Float32.self, at: o) } + public var positiveInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Float32.self, at: o) } @discardableResult public func mutate(positiveInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.positiveInfinityDefault.v); return _accessor.mutate(positiveInfinityDefault, index: o) } - public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -inf : _accessor.readBuffer(of: Float32.self, at: o) } + public var negativeInfDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) } @discardableResult public func mutate(negativeInfDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfDefault.v); return _accessor.mutate(negativeInfDefault, index: o) } - public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -infinity : _accessor.readBuffer(of: Float32.self, at: o) } + public var negativeInfinityDefault: Float32 { let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Float32.self, at: o) } @discardableResult public func mutate(negativeInfinityDefault: Float32) -> Bool {let o = _accessor.offset(VTOFFSET.negativeInfinityDefault.v); return _accessor.mutate(negativeInfinityDefault, index: o) } - public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? inf : _accessor.readBuffer(of: Double.self, at: o) } + public var doubleInfDefault: Double { let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) } @discardableResult public func mutate(doubleInfDefault: Double) -> Bool {let o = _accessor.offset(VTOFFSET.doubleInfDefault.v); return _accessor.mutate(doubleInfDefault, index: o) } public static func startMonster(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 62) } public static func add(pos: MyGame_Example_Vec3?, _ fbb: inout FlatBufferBuilder) { guard let pos = pos else { return }; fbb.create(struct: pos, position: VTOFFSET.pos.p) } @@ -1422,14 +1422,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac public static func add(nativeInline: MyGame_Example_Test?, _ fbb: inout FlatBufferBuilder) { guard let nativeInline = nativeInline else { return }; fbb.create(struct: nativeInline, position: VTOFFSET.nativeInline.p) } public static func add(longEnumNonEnumDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNonEnumDefault.rawValue, def: 0, at: VTOFFSET.longEnumNonEnumDefault.p) } public static func add(longEnumNormalDefault: MyGame_Example_LongEnum, _ fbb: inout FlatBufferBuilder) { fbb.add(element: longEnumNormalDefault.rawValue, def: 2, at: VTOFFSET.longEnumNormalDefault.p) } - public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: nan, at: VTOFFSET.nanDefault.p) } - public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: inf, at: VTOFFSET.infDefault.p) } - public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: +inf, at: VTOFFSET.positiveInfDefault.p) } - public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: infinity, at: VTOFFSET.infinityDefault.p) } - public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: +infinity, at: VTOFFSET.positiveInfinityDefault.p) } - public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -inf, at: VTOFFSET.negativeInfDefault.p) } - public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -infinity, at: VTOFFSET.negativeInfinityDefault.p) } - public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: inf, at: VTOFFSET.doubleInfDefault.p) } + public static func add(nanDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: nanDefault, def: .nan, at: VTOFFSET.nanDefault.p) } + public static func add(infDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infDefault, def: .infinity, at: VTOFFSET.infDefault.p) } + public static func add(positiveInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfDefault, def: .infinity, at: VTOFFSET.positiveInfDefault.p) } + public static func add(infinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: infinityDefault, def: .infinity, at: VTOFFSET.infinityDefault.p) } + public static func add(positiveInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: positiveInfinityDefault, def: .infinity, at: VTOFFSET.positiveInfinityDefault.p) } + public static func add(negativeInfDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfDefault, def: -.infinity, at: VTOFFSET.negativeInfDefault.p) } + public static func add(negativeInfinityDefault: Float32, _ fbb: inout FlatBufferBuilder) { fbb.add(element: negativeInfinityDefault, def: -.infinity, at: VTOFFSET.negativeInfinityDefault.p) } + public static func add(doubleInfDefault: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: doubleInfDefault, def: .infinity, at: VTOFFSET.doubleInfDefault.p) } public static func endMonster(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); fbb.require(table: end, fields: [10]); return end } public static func createMonster( _ fbb: inout FlatBufferBuilder, @@ -1486,14 +1486,14 @@ public struct MyGame_Example_Monster: FlatBufferObject, Verifiable, ObjectAPIPac nativeInline: MyGame_Example_Test? = nil, longEnumNonEnumDefault: MyGame_Example_LongEnum = .longone, longEnumNormalDefault: MyGame_Example_LongEnum = .longone, - nanDefault: Float32 = nan, - infDefault: Float32 = inf, - positiveInfDefault: Float32 = +inf, - infinityDefault: Float32 = infinity, - positiveInfinityDefault: Float32 = +infinity, - negativeInfDefault: Float32 = -inf, - negativeInfinityDefault: Float32 = -infinity, - doubleInfDefault: Double = inf + nanDefault: Float32 = .nan, + infDefault: Float32 = .infinity, + positiveInfDefault: Float32 = .infinity, + infinityDefault: Float32 = .infinity, + positiveInfinityDefault: Float32 = .infinity, + negativeInfDefault: Float32 = -.infinity, + negativeInfinityDefault: Float32 = -.infinity, + doubleInfDefault: Double = .infinity ) -> Offset { let __start = MyGame_Example_Monster.startMonster(&fbb) MyGame_Example_Monster.add(pos: pos, &fbb) @@ -2105,28 +2105,28 @@ extension MyGame_Example_Monster: Encodable { if longEnumNormalDefault != .longone { try container.encodeIfPresent(longEnumNormalDefault, forKey: .longEnumNormalDefault) } - if nanDefault != nan { + if !nanDefault.isNaN { try container.encodeIfPresent(nanDefault, forKey: .nanDefault) } - if infDefault != inf { + if infDefault != .infinity { try container.encodeIfPresent(infDefault, forKey: .infDefault) } - if positiveInfDefault != +inf { + if positiveInfDefault != .infinity { try container.encodeIfPresent(positiveInfDefault, forKey: .positiveInfDefault) } - if infinityDefault != infinity { + if infinityDefault != .infinity { try container.encodeIfPresent(infinityDefault, forKey: .infinityDefault) } - if positiveInfinityDefault != +infinity { + if positiveInfinityDefault != .infinity { try container.encodeIfPresent(positiveInfinityDefault, forKey: .positiveInfinityDefault) } - if negativeInfDefault != -inf { + if negativeInfDefault != -.infinity { try container.encodeIfPresent(negativeInfDefault, forKey: .negativeInfDefault) } - if negativeInfinityDefault != -infinity { + if negativeInfinityDefault != -.infinity { try container.encodeIfPresent(negativeInfinityDefault, forKey: .negativeInfinityDefault) } - if doubleInfDefault != inf { + if doubleInfDefault != .infinity { try container.encodeIfPresent(doubleInfDefault, forKey: .doubleInfDefault) } } @@ -2402,14 +2402,14 @@ public class MyGame_Example_MonsterT: NativeObject { nativeInline = MyGame_Example_Test() longEnumNonEnumDefault = .longone longEnumNormalDefault = .longone - nanDefault = nan - infDefault = inf - positiveInfDefault = +inf - infinityDefault = infinity - positiveInfinityDefault = +infinity - negativeInfDefault = -inf - negativeInfinityDefault = -infinity - doubleInfDefault = inf + nanDefault = .nan + infDefault = .infinity + positiveInfDefault = .infinity + infinityDefault = .infinity + positiveInfinityDefault = .infinity + negativeInfDefault = -.infinity + negativeInfinityDefault = -.infinity + doubleInfDefault = .infinity } public func serialize() -> ByteBuffer { return serialize(type: MyGame_Example_Monster.self) } diff --git a/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/nan_inf_test_generated.swift b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/nan_inf_test_generated.swift new file mode 100644 index 000000000..0e41c7a6b --- /dev/null +++ b/tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/nan_inf_test_generated.swift @@ -0,0 +1,116 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// swiftlint:disable all +// swiftformat:disable all + +import FlatBuffers + +public struct Swift_Tests_NanInfTable: FlatBufferObject, Verifiable { + + static func validateVersion() { FlatBuffersVersion_22_10_26() } + public var __buffer: ByteBuffer! { return _accessor.bb } + private var _accessor: Table + + public static func getRootAsNanInfTable(bb: ByteBuffer) -> Swift_Tests_NanInfTable { return Swift_Tests_NanInfTable(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) } + + private enum VTOFFSET: VOffset { + case defaultNan = 4 + case defaultInf = 6 + case defaultNinf = 8 + case valueNan = 10 + case valueInf = 12 + case valueNinf = 14 + case value = 16 + var v: Int32 { Int32(self.rawValue) } + var p: VOffset { self.rawValue } + } + + public var defaultNan: Double { let o = _accessor.offset(VTOFFSET.defaultNan.v); return o == 0 ? .nan : _accessor.readBuffer(of: Double.self, at: o) } + public var defaultInf: Double { let o = _accessor.offset(VTOFFSET.defaultInf.v); return o == 0 ? .infinity : _accessor.readBuffer(of: Double.self, at: o) } + public var defaultNinf: Double { let o = _accessor.offset(VTOFFSET.defaultNinf.v); return o == 0 ? -.infinity : _accessor.readBuffer(of: Double.self, at: o) } + public var valueNan: Double { let o = _accessor.offset(VTOFFSET.valueNan.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) } + public var valueInf: Double { let o = _accessor.offset(VTOFFSET.valueInf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) } + public var valueNinf: Double { let o = _accessor.offset(VTOFFSET.valueNinf.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) } + public var value: Double { let o = _accessor.offset(VTOFFSET.value.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) } + public static func startNanInfTable(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 7) } + public static func add(defaultNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNan, def: .nan, at: VTOFFSET.defaultNan.p) } + public static func add(defaultInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultInf, def: .infinity, at: VTOFFSET.defaultInf.p) } + public static func add(defaultNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: defaultNinf, def: -.infinity, at: VTOFFSET.defaultNinf.p) } + public static func add(valueNan: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNan, def: 0.0, at: VTOFFSET.valueNan.p) } + public static func add(valueInf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueInf, def: 0.0, at: VTOFFSET.valueInf.p) } + public static func add(valueNinf: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: valueNinf, def: 0.0, at: VTOFFSET.valueNinf.p) } + public static func add(value: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: value, def: 0.0, at: VTOFFSET.value.p) } + public static func endNanInfTable(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end } + public static func createNanInfTable( + _ fbb: inout FlatBufferBuilder, + defaultNan: Double = .nan, + defaultInf: Double = .infinity, + defaultNinf: Double = -.infinity, + valueNan: Double = 0.0, + valueInf: Double = 0.0, + valueNinf: Double = 0.0, + value: Double = 0.0 + ) -> Offset { + let __start = Swift_Tests_NanInfTable.startNanInfTable(&fbb) + Swift_Tests_NanInfTable.add(defaultNan: defaultNan, &fbb) + Swift_Tests_NanInfTable.add(defaultInf: defaultInf, &fbb) + Swift_Tests_NanInfTable.add(defaultNinf: defaultNinf, &fbb) + Swift_Tests_NanInfTable.add(valueNan: valueNan, &fbb) + Swift_Tests_NanInfTable.add(valueInf: valueInf, &fbb) + Swift_Tests_NanInfTable.add(valueNinf: valueNinf, &fbb) + Swift_Tests_NanInfTable.add(value: value, &fbb) + return Swift_Tests_NanInfTable.endNanInfTable(&fbb, start: __start) + } + + public static func verify(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable { + var _v = try verifier.visitTable(at: position) + try _v.visit(field: VTOFFSET.defaultNan.p, fieldName: "defaultNan", required: false, type: Double.self) + try _v.visit(field: VTOFFSET.defaultInf.p, fieldName: "defaultInf", required: false, type: Double.self) + try _v.visit(field: VTOFFSET.defaultNinf.p, fieldName: "defaultNinf", required: false, type: Double.self) + try _v.visit(field: VTOFFSET.valueNan.p, fieldName: "valueNan", required: false, type: Double.self) + try _v.visit(field: VTOFFSET.valueInf.p, fieldName: "valueInf", required: false, type: Double.self) + try _v.visit(field: VTOFFSET.valueNinf.p, fieldName: "valueNinf", required: false, type: Double.self) + try _v.visit(field: VTOFFSET.value.p, fieldName: "value", required: false, type: Double.self) + _v.finish() + } +} + +extension Swift_Tests_NanInfTable: Encodable { + + enum CodingKeys: String, CodingKey { + case defaultNan = "default_nan" + case defaultInf = "default_inf" + case defaultNinf = "default_ninf" + case valueNan = "value_nan" + case valueInf = "value_inf" + case valueNinf = "value_ninf" + case value = "value" + } + public func encode(to encoder: Encoder) throws { + var container = encoder.container(keyedBy: CodingKeys.self) + if !defaultNan.isNaN { + try container.encodeIfPresent(defaultNan, forKey: .defaultNan) + } + if defaultInf != .infinity { + try container.encodeIfPresent(defaultInf, forKey: .defaultInf) + } + if defaultNinf != -.infinity { + try container.encodeIfPresent(defaultNinf, forKey: .defaultNinf) + } + if valueNan != 0.0 { + try container.encodeIfPresent(valueNan, forKey: .valueNan) + } + if valueInf != 0.0 { + try container.encodeIfPresent(valueInf, forKey: .valueInf) + } + if valueNinf != 0.0 { + try container.encodeIfPresent(valueNinf, forKey: .valueNinf) + } + if value != 0.0 { + try container.encodeIfPresent(value, forKey: .value) + } + } +} +