mirror of
https://github.com/google/flatbuffers.git
synced 2025-04-08 01:02:04 +08:00
* [swift] fix broken swift test build (#7633) * [swift] fix unused variable (#7633) * [swift] update generated code (#7633) * [swift] add binary & json test for nan, inf, -inf for swift (#7633) * [swift] use just '.infinity' instead of '+.infinity' (#7633) * [swift] remove commented code (#7633) Co-authored-by: Derek Bailey <derekbailey@google.com> Co-authored-by: mustiikhalil <26250654+mustiikhalil@users.noreply.github.com>
This commit is contained in:
mr-swifter
GitHub
parent
879622fc57
commit
74756e5d1b
@ -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",
|
||||
|
||||
@ -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) + ") ";
|
||||
}
|
||||
|
||||
14
tests/nan_inf_test.fbs
Normal file
14
tests/nan_inf_test.fbs
Normal file
@ -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;
|
||||
@ -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) }
|
||||
|
||||
@ -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\"}"
|
||||
}
|
||||
|
||||
}
|
||||
@ -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) }
|
||||
|
||||
@ -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<T>(_ 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)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user