BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-28 08:48:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

[swift] fix broken swift test build (#7633) (#7634)

Browse Source 
* [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
2022-11-11 20:36:47 +03:00
committed by GitHub
parent 879622fc57
commit 74756e5d1b
7 changed files with 389 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/FlatBuffersNanInfTests.swift Normal file
View File

@@ -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\"}"
}
}

80
tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/monster_test_generated.swift
View File

@@ -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) }

116
tests/swift/tests/Tests/FlatBuffers.Test.SwiftTests/nan_inf_test_generated.swift Normal file
View File

@@ -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)
}
}
}