mirror of
https://github.com/google/flatbuffers.git
synced 2026-06-10 23:17:27 +00:00
Fix handling of +/-inf defaults in TS/rust/go/dart codegen (#7588)
+/-inf were not being handled, and so invalid typescript was being generated when a float/double had an infinite default value. NaN was being handled correctly. Co-authored-by: Derek Bailey <derekbailey@google.com> Co-authored-by: Casper <casperneo@uchicago.edu>
This commit is contained in:
James Kuszmaul
@@ -215,6 +215,22 @@ public struct Monster : IFlatbufferObject
|
||||
public bool MutateLongEnumNonEnumDefault(MyGame.Example.LongEnum long_enum_non_enum_default) { int o = __p.__offset(108); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, (ulong)long_enum_non_enum_default); return true; } else { return false; } }
|
||||
public MyGame.Example.LongEnum LongEnumNormalDefault { get { int o = __p.__offset(110); return o != 0 ? (MyGame.Example.LongEnum)__p.bb.GetUlong(o + __p.bb_pos) : MyGame.Example.LongEnum.LongOne; } }
|
||||
public bool MutateLongEnumNormalDefault(MyGame.Example.LongEnum long_enum_normal_default) { int o = __p.__offset(110); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, (ulong)long_enum_normal_default); return true; } else { return false; } }
|
||||
public float NanDefault { get { int o = __p.__offset(112); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NaN; } }
|
||||
public bool MutateNanDefault(float nan_default) { int o = __p.__offset(112); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, nan_default); return true; } else { return false; } }
|
||||
public float InfDefault { get { int o = __p.__offset(114); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
|
||||
public bool MutateInfDefault(float inf_default) { int o = __p.__offset(114); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, inf_default); return true; } else { return false; } }
|
||||
public float PositiveInfDefault { get { int o = __p.__offset(116); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
|
||||
public bool MutatePositiveInfDefault(float positive_inf_default) { int o = __p.__offset(116); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, positive_inf_default); return true; } else { return false; } }
|
||||
public float InfinityDefault { get { int o = __p.__offset(118); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
|
||||
public bool MutateInfinityDefault(float infinity_default) { int o = __p.__offset(118); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, infinity_default); return true; } else { return false; } }
|
||||
public float PositiveInfinityDefault { get { int o = __p.__offset(120); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.PositiveInfinity; } }
|
||||
public bool MutatePositiveInfinityDefault(float positive_infinity_default) { int o = __p.__offset(120); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, positive_infinity_default); return true; } else { return false; } }
|
||||
public float NegativeInfDefault { get { int o = __p.__offset(122); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NegativeInfinity; } }
|
||||
public bool MutateNegativeInfDefault(float negative_inf_default) { int o = __p.__offset(122); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, negative_inf_default); return true; } else { return false; } }
|
||||
public float NegativeInfinityDefault { get { int o = __p.__offset(124); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)Single.NegativeInfinity; } }
|
||||
public bool MutateNegativeInfinityDefault(float negative_infinity_default) { int o = __p.__offset(124); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, negative_infinity_default); return true; } else { return false; } }
|
||||
public double DoubleInfDefault { get { int o = __p.__offset(126); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)Double.PositiveInfinity; } }
|
||||
public bool MutateDoubleInfDefault(double double_inf_default) { int o = __p.__offset(126); if (o != 0) { __p.bb.PutDouble(o + __p.bb_pos, double_inf_default); return true; } else { return false; } }
|
||||
|
||||
public static Offset<MyGame.Example.Monster> CreateMonster(FlatBufferBuilder builder,
|
||||
MyGame.Example.Vec3T pos = null,
|
||||
@@ -269,8 +285,17 @@ public struct Monster : IFlatbufferObject
|
||||
VectorOffset scalar_key_sorted_tablesOffset = default(VectorOffset),
|
||||
MyGame.Example.TestT native_inline = null,
|
||||
MyGame.Example.LongEnum long_enum_non_enum_default = 0,
|
||||
MyGame.Example.LongEnum long_enum_normal_default = MyGame.Example.LongEnum.LongOne) {
|
||||
builder.StartTable(54);
|
||||
MyGame.Example.LongEnum long_enum_normal_default = MyGame.Example.LongEnum.LongOne,
|
||||
float nan_default = Single.NaN,
|
||||
float inf_default = Single.PositiveInfinity,
|
||||
float positive_inf_default = Single.PositiveInfinity,
|
||||
float infinity_default = Single.PositiveInfinity,
|
||||
float positive_infinity_default = Single.PositiveInfinity,
|
||||
float negative_inf_default = Single.NegativeInfinity,
|
||||
float negative_infinity_default = Single.NegativeInfinity,
|
||||
double double_inf_default = Double.PositiveInfinity) {
|
||||
builder.StartTable(62);
|
||||
Monster.AddDoubleInfDefault(builder, double_inf_default);
|
||||
Monster.AddLongEnumNormalDefault(builder, long_enum_normal_default);
|
||||
Monster.AddLongEnumNonEnumDefault(builder, long_enum_non_enum_default);
|
||||
Monster.AddNonOwningReference(builder, non_owning_reference);
|
||||
@@ -280,6 +305,13 @@ public struct Monster : IFlatbufferObject
|
||||
Monster.AddTesthashs64Fnv1a(builder, testhashs64_fnv1a);
|
||||
Monster.AddTesthashu64Fnv1(builder, testhashu64_fnv1);
|
||||
Monster.AddTesthashs64Fnv1(builder, testhashs64_fnv1);
|
||||
Monster.AddNegativeInfinityDefault(builder, negative_infinity_default);
|
||||
Monster.AddNegativeInfDefault(builder, negative_inf_default);
|
||||
Monster.AddPositiveInfinityDefault(builder, positive_infinity_default);
|
||||
Monster.AddInfinityDefault(builder, infinity_default);
|
||||
Monster.AddPositiveInfDefault(builder, positive_inf_default);
|
||||
Monster.AddInfDefault(builder, inf_default);
|
||||
Monster.AddNanDefault(builder, nan_default);
|
||||
Monster.AddNativeInline(builder, MyGame.Example.Test.Pack(builder, native_inline));
|
||||
Monster.AddScalarKeySortedTables(builder, scalar_key_sorted_tablesOffset);
|
||||
Monster.AddTestrequirednestedflatbuffer(builder, testrequirednestedflatbufferOffset);
|
||||
@@ -327,7 +359,7 @@ public struct Monster : IFlatbufferObject
|
||||
return Monster.EndMonster(builder);
|
||||
}
|
||||
|
||||
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(54); }
|
||||
public static void StartMonster(FlatBufferBuilder builder) { builder.StartTable(62); }
|
||||
public static void AddPos(FlatBufferBuilder builder, Offset<MyGame.Example.Vec3> posOffset) { builder.AddStruct(0, posOffset.Value, 0); }
|
||||
public static void AddMana(FlatBufferBuilder builder, short mana) { builder.AddShort(1, mana, 150); }
|
||||
public static void AddHp(FlatBufferBuilder builder, short hp) { builder.AddShort(2, hp, 100); }
|
||||
@@ -469,6 +501,14 @@ public struct Monster : IFlatbufferObject
|
||||
public static void AddNativeInline(FlatBufferBuilder builder, Offset<MyGame.Example.Test> nativeInlineOffset) { builder.AddStruct(51, nativeInlineOffset.Value, 0); }
|
||||
public static void AddLongEnumNonEnumDefault(FlatBufferBuilder builder, MyGame.Example.LongEnum longEnumNonEnumDefault) { builder.AddUlong(52, (ulong)longEnumNonEnumDefault, 0); }
|
||||
public static void AddLongEnumNormalDefault(FlatBufferBuilder builder, MyGame.Example.LongEnum longEnumNormalDefault) { builder.AddUlong(53, (ulong)longEnumNormalDefault, 2); }
|
||||
public static void AddNanDefault(FlatBufferBuilder builder, float nanDefault) { builder.AddFloat(54, nanDefault, Single.NaN); }
|
||||
public static void AddInfDefault(FlatBufferBuilder builder, float infDefault) { builder.AddFloat(55, infDefault, Single.PositiveInfinity); }
|
||||
public static void AddPositiveInfDefault(FlatBufferBuilder builder, float positiveInfDefault) { builder.AddFloat(56, positiveInfDefault, Single.PositiveInfinity); }
|
||||
public static void AddInfinityDefault(FlatBufferBuilder builder, float infinityDefault) { builder.AddFloat(57, infinityDefault, Single.PositiveInfinity); }
|
||||
public static void AddPositiveInfinityDefault(FlatBufferBuilder builder, float positiveInfinityDefault) { builder.AddFloat(58, positiveInfinityDefault, Single.PositiveInfinity); }
|
||||
public static void AddNegativeInfDefault(FlatBufferBuilder builder, float negativeInfDefault) { builder.AddFloat(59, negativeInfDefault, Single.NegativeInfinity); }
|
||||
public static void AddNegativeInfinityDefault(FlatBufferBuilder builder, float negativeInfinityDefault) { builder.AddFloat(60, negativeInfinityDefault, Single.NegativeInfinity); }
|
||||
public static void AddDoubleInfDefault(FlatBufferBuilder builder, double doubleInfDefault) { builder.AddDouble(61, doubleInfDefault, Double.PositiveInfinity); }
|
||||
public static Offset<MyGame.Example.Monster> EndMonster(FlatBufferBuilder builder) {
|
||||
int o = builder.EndTable();
|
||||
builder.Required(o, 10); // name
|
||||
@@ -620,6 +660,14 @@ public struct Monster : IFlatbufferObject
|
||||
_o.NativeInline = this.NativeInline.HasValue ? this.NativeInline.Value.UnPack() : null;
|
||||
_o.LongEnumNonEnumDefault = this.LongEnumNonEnumDefault;
|
||||
_o.LongEnumNormalDefault = this.LongEnumNormalDefault;
|
||||
_o.NanDefault = this.NanDefault;
|
||||
_o.InfDefault = this.InfDefault;
|
||||
_o.PositiveInfDefault = this.PositiveInfDefault;
|
||||
_o.InfinityDefault = this.InfinityDefault;
|
||||
_o.PositiveInfinityDefault = this.PositiveInfinityDefault;
|
||||
_o.NegativeInfDefault = this.NegativeInfDefault;
|
||||
_o.NegativeInfinityDefault = this.NegativeInfinityDefault;
|
||||
_o.DoubleInfDefault = this.DoubleInfDefault;
|
||||
}
|
||||
public static Offset<MyGame.Example.Monster> Pack(FlatBufferBuilder builder, MonsterT _o) {
|
||||
if (_o == null) return default(Offset<MyGame.Example.Monster>);
|
||||
@@ -796,7 +844,15 @@ public struct Monster : IFlatbufferObject
|
||||
_scalar_key_sorted_tables,
|
||||
_o.NativeInline,
|
||||
_o.LongEnumNonEnumDefault,
|
||||
_o.LongEnumNormalDefault);
|
||||
_o.LongEnumNormalDefault,
|
||||
_o.NanDefault,
|
||||
_o.InfDefault,
|
||||
_o.PositiveInfDefault,
|
||||
_o.InfinityDefault,
|
||||
_o.PositiveInfinityDefault,
|
||||
_o.NegativeInfDefault,
|
||||
_o.NegativeInfinityDefault,
|
||||
_o.DoubleInfDefault);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -949,6 +1005,22 @@ public class MonsterT
|
||||
public MyGame.Example.LongEnum LongEnumNonEnumDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("long_enum_normal_default")]
|
||||
public MyGame.Example.LongEnum LongEnumNormalDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("nan_default")]
|
||||
public float NanDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("inf_default")]
|
||||
public float InfDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("positive_inf_default")]
|
||||
public float PositiveInfDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("infinity_default")]
|
||||
public float InfinityDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("positive_infinity_default")]
|
||||
public float PositiveInfinityDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("negative_inf_default")]
|
||||
public float NegativeInfDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("negative_infinity_default")]
|
||||
public float NegativeInfinityDefault { get; set; }
|
||||
[Newtonsoft.Json.JsonProperty("double_inf_default")]
|
||||
public double DoubleInfDefault { get; set; }
|
||||
|
||||
public MonsterT() {
|
||||
this.Pos = new MyGame.Example.Vec3T();
|
||||
@@ -1001,6 +1073,14 @@ public class MonsterT
|
||||
this.NativeInline = new MyGame.Example.TestT();
|
||||
this.LongEnumNonEnumDefault = 0;
|
||||
this.LongEnumNormalDefault = MyGame.Example.LongEnum.LongOne;
|
||||
this.NanDefault = Single.NaN;
|
||||
this.InfDefault = Single.PositiveInfinity;
|
||||
this.PositiveInfDefault = Single.PositiveInfinity;
|
||||
this.InfinityDefault = Single.PositiveInfinity;
|
||||
this.PositiveInfinityDefault = Single.PositiveInfinity;
|
||||
this.NegativeInfDefault = Single.NegativeInfinity;
|
||||
this.NegativeInfinityDefault = Single.NegativeInfinity;
|
||||
this.DoubleInfDefault = Double.PositiveInfinity;
|
||||
}
|
||||
|
||||
public static MonsterT DeserializeFromJson(string jsonText) {
|
||||
|
||||
@@ -3,6 +3,8 @@
|
||||
package Example
|
||||
|
||||
import (
|
||||
"math"
|
||||
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
|
||||
MyGame "MyGame"
|
||||
@@ -60,6 +62,14 @@ type MonsterT struct {
|
||||
NativeInline *TestT `json:"native_inline"`
|
||||
LongEnumNonEnumDefault LongEnum `json:"long_enum_non_enum_default"`
|
||||
LongEnumNormalDefault LongEnum `json:"long_enum_normal_default"`
|
||||
NanDefault float32 `json:"nan_default"`
|
||||
InfDefault float32 `json:"inf_default"`
|
||||
PositiveInfDefault float32 `json:"positive_inf_default"`
|
||||
InfinityDefault float32 `json:"infinity_default"`
|
||||
PositiveInfinityDefault float32 `json:"positive_infinity_default"`
|
||||
NegativeInfDefault float32 `json:"negative_inf_default"`
|
||||
NegativeInfinityDefault float32 `json:"negative_infinity_default"`
|
||||
DoubleInfDefault float64 `json:"double_inf_default"`
|
||||
}
|
||||
|
||||
func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
@@ -320,6 +330,14 @@ func (t *MonsterT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
MonsterAddNativeInline(builder, nativeInlineOffset)
|
||||
MonsterAddLongEnumNonEnumDefault(builder, t.LongEnumNonEnumDefault)
|
||||
MonsterAddLongEnumNormalDefault(builder, t.LongEnumNormalDefault)
|
||||
MonsterAddNanDefault(builder, t.NanDefault)
|
||||
MonsterAddInfDefault(builder, t.InfDefault)
|
||||
MonsterAddPositiveInfDefault(builder, t.PositiveInfDefault)
|
||||
MonsterAddInfinityDefault(builder, t.InfinityDefault)
|
||||
MonsterAddPositiveInfinityDefault(builder, t.PositiveInfinityDefault)
|
||||
MonsterAddNegativeInfDefault(builder, t.NegativeInfDefault)
|
||||
MonsterAddNegativeInfinityDefault(builder, t.NegativeInfinityDefault)
|
||||
MonsterAddDoubleInfDefault(builder, t.DoubleInfDefault)
|
||||
return MonsterEnd(builder)
|
||||
}
|
||||
|
||||
@@ -461,6 +479,14 @@ func (rcv *Monster) UnPackTo(t *MonsterT) {
|
||||
t.NativeInline = rcv.NativeInline(nil).UnPack()
|
||||
t.LongEnumNonEnumDefault = rcv.LongEnumNonEnumDefault()
|
||||
t.LongEnumNormalDefault = rcv.LongEnumNormalDefault()
|
||||
t.NanDefault = rcv.NanDefault()
|
||||
t.InfDefault = rcv.InfDefault()
|
||||
t.PositiveInfDefault = rcv.PositiveInfDefault()
|
||||
t.InfinityDefault = rcv.InfinityDefault()
|
||||
t.PositiveInfinityDefault = rcv.PositiveInfinityDefault()
|
||||
t.NegativeInfDefault = rcv.NegativeInfDefault()
|
||||
t.NegativeInfinityDefault = rcv.NegativeInfinityDefault()
|
||||
t.DoubleInfDefault = rcv.DoubleInfDefault()
|
||||
}
|
||||
|
||||
func (rcv *Monster) UnPack() *MonsterT {
|
||||
@@ -1386,8 +1412,104 @@ func (rcv *Monster) MutateLongEnumNormalDefault(n LongEnum) bool {
|
||||
return rcv._tab.MutateUint64Slot(110, uint64(n))
|
||||
}
|
||||
|
||||
func (rcv *Monster) NanDefault() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(112))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return float32(math.NaN())
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutateNanDefault(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(112, n)
|
||||
}
|
||||
|
||||
func (rcv *Monster) InfDefault() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(114))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return float32(math.Inf(1))
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutateInfDefault(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(114, n)
|
||||
}
|
||||
|
||||
func (rcv *Monster) PositiveInfDefault() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(116))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return float32(math.Inf(1))
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutatePositiveInfDefault(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(116, n)
|
||||
}
|
||||
|
||||
func (rcv *Monster) InfinityDefault() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(118))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return float32(math.Inf(1))
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutateInfinityDefault(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(118, n)
|
||||
}
|
||||
|
||||
func (rcv *Monster) PositiveInfinityDefault() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(120))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return float32(math.Inf(1))
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutatePositiveInfinityDefault(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(120, n)
|
||||
}
|
||||
|
||||
func (rcv *Monster) NegativeInfDefault() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(122))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return float32(math.Inf(-1))
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutateNegativeInfDefault(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(122, n)
|
||||
}
|
||||
|
||||
func (rcv *Monster) NegativeInfinityDefault() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(124))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return float32(math.Inf(-1))
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutateNegativeInfinityDefault(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(124, n)
|
||||
}
|
||||
|
||||
func (rcv *Monster) DoubleInfDefault() float64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(126))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat64(o + rcv._tab.Pos)
|
||||
}
|
||||
return float64(math.Inf(1))
|
||||
}
|
||||
|
||||
func (rcv *Monster) MutateDoubleInfDefault(n float64) bool {
|
||||
return rcv._tab.MutateFloat64Slot(126, n)
|
||||
}
|
||||
|
||||
func MonsterStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(54)
|
||||
builder.StartObject(62)
|
||||
}
|
||||
func MonsterAddPos(builder *flatbuffers.Builder, pos flatbuffers.UOffsetT) {
|
||||
builder.PrependStructSlot(0, flatbuffers.UOffsetT(pos), 0)
|
||||
@@ -1608,6 +1730,30 @@ func MonsterAddLongEnumNonEnumDefault(builder *flatbuffers.Builder, longEnumNonE
|
||||
func MonsterAddLongEnumNormalDefault(builder *flatbuffers.Builder, longEnumNormalDefault LongEnum) {
|
||||
builder.PrependUint64Slot(53, uint64(longEnumNormalDefault), 2)
|
||||
}
|
||||
func MonsterAddNanDefault(builder *flatbuffers.Builder, nanDefault float32) {
|
||||
builder.PrependFloat32Slot(54, nanDefault, float32(math.NaN()))
|
||||
}
|
||||
func MonsterAddInfDefault(builder *flatbuffers.Builder, infDefault float32) {
|
||||
builder.PrependFloat32Slot(55, infDefault, float32(math.Inf(1)))
|
||||
}
|
||||
func MonsterAddPositiveInfDefault(builder *flatbuffers.Builder, positiveInfDefault float32) {
|
||||
builder.PrependFloat32Slot(56, positiveInfDefault, float32(math.Inf(1)))
|
||||
}
|
||||
func MonsterAddInfinityDefault(builder *flatbuffers.Builder, infinityDefault float32) {
|
||||
builder.PrependFloat32Slot(57, infinityDefault, float32(math.Inf(1)))
|
||||
}
|
||||
func MonsterAddPositiveInfinityDefault(builder *flatbuffers.Builder, positiveInfinityDefault float32) {
|
||||
builder.PrependFloat32Slot(58, positiveInfinityDefault, float32(math.Inf(1)))
|
||||
}
|
||||
func MonsterAddNegativeInfDefault(builder *flatbuffers.Builder, negativeInfDefault float32) {
|
||||
builder.PrependFloat32Slot(59, negativeInfDefault, float32(math.Inf(-1)))
|
||||
}
|
||||
func MonsterAddNegativeInfinityDefault(builder *flatbuffers.Builder, negativeInfinityDefault float32) {
|
||||
builder.PrependFloat32Slot(60, negativeInfinityDefault, float32(math.Inf(-1)))
|
||||
}
|
||||
func MonsterAddDoubleInfDefault(builder *flatbuffers.Builder, doubleInfDefault float64) {
|
||||
builder.PrependFloat64Slot(61, doubleInfDefault, float64(math.Inf(1)))
|
||||
}
|
||||
func MonsterEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
|
||||
@@ -216,8 +216,24 @@ public final class Monster extends Table {
|
||||
public boolean mutateLongEnumNonEnumDefault(long long_enum_non_enum_default) { int o = __offset(108); if (o != 0) { bb.putLong(o + bb_pos, long_enum_non_enum_default); return true; } else { return false; } }
|
||||
public long longEnumNormalDefault() { int o = __offset(110); return o != 0 ? bb.getLong(o + bb_pos) : 2L; }
|
||||
public boolean mutateLongEnumNormalDefault(long long_enum_normal_default) { int o = __offset(110); if (o != 0) { bb.putLong(o + bb_pos, long_enum_normal_default); return true; } else { return false; } }
|
||||
public float nanDefault() { int o = __offset(112); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NaN; }
|
||||
public boolean mutateNanDefault(float nan_default) { int o = __offset(112); if (o != 0) { bb.putFloat(o + bb_pos, nan_default); return true; } else { return false; } }
|
||||
public float infDefault() { int o = __offset(114); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
|
||||
public boolean mutateInfDefault(float inf_default) { int o = __offset(114); if (o != 0) { bb.putFloat(o + bb_pos, inf_default); return true; } else { return false; } }
|
||||
public float positiveInfDefault() { int o = __offset(116); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
|
||||
public boolean mutatePositiveInfDefault(float positive_inf_default) { int o = __offset(116); if (o != 0) { bb.putFloat(o + bb_pos, positive_inf_default); return true; } else { return false; } }
|
||||
public float infinityDefault() { int o = __offset(118); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
|
||||
public boolean mutateInfinityDefault(float infinity_default) { int o = __offset(118); if (o != 0) { bb.putFloat(o + bb_pos, infinity_default); return true; } else { return false; } }
|
||||
public float positiveInfinityDefault() { int o = __offset(120); return o != 0 ? bb.getFloat(o + bb_pos) : Float.POSITIVE_INFINITY; }
|
||||
public boolean mutatePositiveInfinityDefault(float positive_infinity_default) { int o = __offset(120); if (o != 0) { bb.putFloat(o + bb_pos, positive_infinity_default); return true; } else { return false; } }
|
||||
public float negativeInfDefault() { int o = __offset(122); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NEGATIVE_INFINITY; }
|
||||
public boolean mutateNegativeInfDefault(float negative_inf_default) { int o = __offset(122); if (o != 0) { bb.putFloat(o + bb_pos, negative_inf_default); return true; } else { return false; } }
|
||||
public float negativeInfinityDefault() { int o = __offset(124); return o != 0 ? bb.getFloat(o + bb_pos) : Float.NEGATIVE_INFINITY; }
|
||||
public boolean mutateNegativeInfinityDefault(float negative_infinity_default) { int o = __offset(124); if (o != 0) { bb.putFloat(o + bb_pos, negative_infinity_default); return true; } else { return false; } }
|
||||
public double doubleInfDefault() { int o = __offset(126); return o != 0 ? bb.getDouble(o + bb_pos) : Double.POSITIVE_INFINITY; }
|
||||
public boolean mutateDoubleInfDefault(double double_inf_default) { int o = __offset(126); if (o != 0) { bb.putDouble(o + bb_pos, double_inf_default); return true; } else { return false; } }
|
||||
|
||||
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(54); }
|
||||
public static void startMonster(FlatBufferBuilder builder) { builder.startTable(62); }
|
||||
public static void addPos(FlatBufferBuilder builder, int posOffset) { builder.addStruct(0, posOffset, 0); }
|
||||
public static void addMana(FlatBufferBuilder builder, short mana) { builder.addShort(1, mana, 150); }
|
||||
public static void addHp(FlatBufferBuilder builder, short hp) { builder.addShort(2, hp, 100); }
|
||||
@@ -313,6 +329,14 @@ public final class Monster extends Table {
|
||||
public static void addNativeInline(FlatBufferBuilder builder, int nativeInlineOffset) { builder.addStruct(51, nativeInlineOffset, 0); }
|
||||
public static void addLongEnumNonEnumDefault(FlatBufferBuilder builder, long longEnumNonEnumDefault) { builder.addLong(52, longEnumNonEnumDefault, 0L); }
|
||||
public static void addLongEnumNormalDefault(FlatBufferBuilder builder, long longEnumNormalDefault) { builder.addLong(53, longEnumNormalDefault, 2L); }
|
||||
public static void addNanDefault(FlatBufferBuilder builder, float nanDefault) { builder.addFloat(54, nanDefault, Float.NaN); }
|
||||
public static void addInfDefault(FlatBufferBuilder builder, float infDefault) { builder.addFloat(55, infDefault, Float.POSITIVE_INFINITY); }
|
||||
public static void addPositiveInfDefault(FlatBufferBuilder builder, float positiveInfDefault) { builder.addFloat(56, positiveInfDefault, Float.POSITIVE_INFINITY); }
|
||||
public static void addInfinityDefault(FlatBufferBuilder builder, float infinityDefault) { builder.addFloat(57, infinityDefault, Float.POSITIVE_INFINITY); }
|
||||
public static void addPositiveInfinityDefault(FlatBufferBuilder builder, float positiveInfinityDefault) { builder.addFloat(58, positiveInfinityDefault, Float.POSITIVE_INFINITY); }
|
||||
public static void addNegativeInfDefault(FlatBufferBuilder builder, float negativeInfDefault) { builder.addFloat(59, negativeInfDefault, Float.NEGATIVE_INFINITY); }
|
||||
public static void addNegativeInfinityDefault(FlatBufferBuilder builder, float negativeInfinityDefault) { builder.addFloat(60, negativeInfinityDefault, Float.NEGATIVE_INFINITY); }
|
||||
public static void addDoubleInfDefault(FlatBufferBuilder builder, double doubleInfDefault) { builder.addDouble(61, doubleInfDefault, Double.POSITIVE_INFINITY); }
|
||||
public static int endMonster(FlatBufferBuilder builder) {
|
||||
int o = builder.endTable();
|
||||
builder.required(o, 10); // name
|
||||
@@ -533,6 +557,22 @@ public final class Monster extends Table {
|
||||
_o.setLongEnumNonEnumDefault(_oLongEnumNonEnumDefault);
|
||||
long _oLongEnumNormalDefault = longEnumNormalDefault();
|
||||
_o.setLongEnumNormalDefault(_oLongEnumNormalDefault);
|
||||
float _oNanDefault = nanDefault();
|
||||
_o.setNanDefault(_oNanDefault);
|
||||
float _oInfDefault = infDefault();
|
||||
_o.setInfDefault(_oInfDefault);
|
||||
float _oPositiveInfDefault = positiveInfDefault();
|
||||
_o.setPositiveInfDefault(_oPositiveInfDefault);
|
||||
float _oInfinityDefault = infinityDefault();
|
||||
_o.setInfinityDefault(_oInfinityDefault);
|
||||
float _oPositiveInfinityDefault = positiveInfinityDefault();
|
||||
_o.setPositiveInfinityDefault(_oPositiveInfinityDefault);
|
||||
float _oNegativeInfDefault = negativeInfDefault();
|
||||
_o.setNegativeInfDefault(_oNegativeInfDefault);
|
||||
float _oNegativeInfinityDefault = negativeInfinityDefault();
|
||||
_o.setNegativeInfinityDefault(_oNegativeInfinityDefault);
|
||||
double _oDoubleInfDefault = doubleInfDefault();
|
||||
_o.setDoubleInfDefault(_oDoubleInfDefault);
|
||||
}
|
||||
public static int pack(FlatBufferBuilder builder, MonsterT _o) {
|
||||
if (_o == null) return 0;
|
||||
@@ -725,6 +765,14 @@ public final class Monster extends Table {
|
||||
addNativeInline(builder, MyGame.Example.Test.pack(builder, _o.getNativeInline()));
|
||||
addLongEnumNonEnumDefault(builder, _o.getLongEnumNonEnumDefault());
|
||||
addLongEnumNormalDefault(builder, _o.getLongEnumNormalDefault());
|
||||
addNanDefault(builder, _o.getNanDefault());
|
||||
addInfDefault(builder, _o.getInfDefault());
|
||||
addPositiveInfDefault(builder, _o.getPositiveInfDefault());
|
||||
addInfinityDefault(builder, _o.getInfinityDefault());
|
||||
addPositiveInfinityDefault(builder, _o.getPositiveInfinityDefault());
|
||||
addNegativeInfDefault(builder, _o.getNegativeInfDefault());
|
||||
addNegativeInfinityDefault(builder, _o.getNegativeInfinityDefault());
|
||||
addDoubleInfDefault(builder, _o.getDoubleInfDefault());
|
||||
return endMonster(builder);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -870,6 +870,118 @@ class Monster : Table() {
|
||||
false
|
||||
}
|
||||
}
|
||||
val nanDefault : Float
|
||||
get() {
|
||||
val o = __offset(112)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NaN
|
||||
}
|
||||
fun mutateNanDefault(nanDefault: Float) : Boolean {
|
||||
val o = __offset(112)
|
||||
return if (o != 0) {
|
||||
bb.putFloat(o + bb_pos, nanDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
val infDefault : Float
|
||||
get() {
|
||||
val o = __offset(114)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
|
||||
}
|
||||
fun mutateInfDefault(infDefault: Float) : Boolean {
|
||||
val o = __offset(114)
|
||||
return if (o != 0) {
|
||||
bb.putFloat(o + bb_pos, infDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
val positiveInfDefault : Float
|
||||
get() {
|
||||
val o = __offset(116)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
|
||||
}
|
||||
fun mutatePositiveInfDefault(positiveInfDefault: Float) : Boolean {
|
||||
val o = __offset(116)
|
||||
return if (o != 0) {
|
||||
bb.putFloat(o + bb_pos, positiveInfDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
val infinityDefault : Float
|
||||
get() {
|
||||
val o = __offset(118)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
|
||||
}
|
||||
fun mutateInfinityDefault(infinityDefault: Float) : Boolean {
|
||||
val o = __offset(118)
|
||||
return if (o != 0) {
|
||||
bb.putFloat(o + bb_pos, infinityDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
val positiveInfinityDefault : Float
|
||||
get() {
|
||||
val o = __offset(120)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else Float.POSITIVE_INFINITY
|
||||
}
|
||||
fun mutatePositiveInfinityDefault(positiveInfinityDefault: Float) : Boolean {
|
||||
val o = __offset(120)
|
||||
return if (o != 0) {
|
||||
bb.putFloat(o + bb_pos, positiveInfinityDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
val negativeInfDefault : Float
|
||||
get() {
|
||||
val o = __offset(122)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NEGATIVE_INFINITY
|
||||
}
|
||||
fun mutateNegativeInfDefault(negativeInfDefault: Float) : Boolean {
|
||||
val o = __offset(122)
|
||||
return if (o != 0) {
|
||||
bb.putFloat(o + bb_pos, negativeInfDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
val negativeInfinityDefault : Float
|
||||
get() {
|
||||
val o = __offset(124)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else Float.NEGATIVE_INFINITY
|
||||
}
|
||||
fun mutateNegativeInfinityDefault(negativeInfinityDefault: Float) : Boolean {
|
||||
val o = __offset(124)
|
||||
return if (o != 0) {
|
||||
bb.putFloat(o + bb_pos, negativeInfinityDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
val doubleInfDefault : Double
|
||||
get() {
|
||||
val o = __offset(126)
|
||||
return if(o != 0) bb.getDouble(o + bb_pos) else Double.POSITIVE_INFINITY
|
||||
}
|
||||
fun mutateDoubleInfDefault(doubleInfDefault: Double) : Boolean {
|
||||
val o = __offset(126)
|
||||
return if (o != 0) {
|
||||
bb.putDouble(o + bb_pos, doubleInfDefault)
|
||||
true
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
override fun keysCompare(o1: Int, o2: Int, _bb: ByteBuffer) : Int {
|
||||
return compareStrings(__offset(10, o1, _bb), __offset(10, o2, _bb), _bb)
|
||||
}
|
||||
@@ -881,7 +993,7 @@ class Monster : Table() {
|
||||
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
|
||||
}
|
||||
fun MonsterBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "MONS")
|
||||
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(54)
|
||||
fun startMonster(builder: FlatBufferBuilder) = builder.startTable(62)
|
||||
fun addPos(builder: FlatBufferBuilder, pos: Int) = builder.addStruct(0, pos, 0)
|
||||
fun addMana(builder: FlatBufferBuilder, mana: Short) = builder.addShort(1, mana, 150)
|
||||
fun addHp(builder: FlatBufferBuilder, hp: Short) = builder.addShort(2, hp, 100)
|
||||
@@ -1077,6 +1189,14 @@ class Monster : Table() {
|
||||
fun addNativeInline(builder: FlatBufferBuilder, nativeInline: Int) = builder.addStruct(51, nativeInline, 0)
|
||||
fun addLongEnumNonEnumDefault(builder: FlatBufferBuilder, longEnumNonEnumDefault: ULong) = builder.addLong(52, longEnumNonEnumDefault.toLong(), 0)
|
||||
fun addLongEnumNormalDefault(builder: FlatBufferBuilder, longEnumNormalDefault: ULong) = builder.addLong(53, longEnumNormalDefault.toLong(), 2)
|
||||
fun addNanDefault(builder: FlatBufferBuilder, nanDefault: Float) = builder.addFloat(54, nanDefault, Double.NaN)
|
||||
fun addInfDefault(builder: FlatBufferBuilder, infDefault: Float) = builder.addFloat(55, infDefault, Double.POSITIVE_INFINITY)
|
||||
fun addPositiveInfDefault(builder: FlatBufferBuilder, positiveInfDefault: Float) = builder.addFloat(56, positiveInfDefault, Double.POSITIVE_INFINITY)
|
||||
fun addInfinityDefault(builder: FlatBufferBuilder, infinityDefault: Float) = builder.addFloat(57, infinityDefault, Double.POSITIVE_INFINITY)
|
||||
fun addPositiveInfinityDefault(builder: FlatBufferBuilder, positiveInfinityDefault: Float) = builder.addFloat(58, positiveInfinityDefault, Double.POSITIVE_INFINITY)
|
||||
fun addNegativeInfDefault(builder: FlatBufferBuilder, negativeInfDefault: Float) = builder.addFloat(59, negativeInfDefault, Double.NEGATIVE_INFINITY)
|
||||
fun addNegativeInfinityDefault(builder: FlatBufferBuilder, negativeInfinityDefault: Float) = builder.addFloat(60, negativeInfinityDefault, Double.NEGATIVE_INFINITY)
|
||||
fun addDoubleInfDefault(builder: FlatBufferBuilder, doubleInfDefault: Double) = builder.addDouble(61, doubleInfDefault, Double.POSITIVE_INFINITY)
|
||||
fun endMonster(builder: FlatBufferBuilder) : Int {
|
||||
val o = builder.endTable()
|
||||
builder.required(o, 10)
|
||||
|
||||
@@ -703,8 +703,72 @@ function mt:LongEnumNormalDefault()
|
||||
return 2
|
||||
end
|
||||
|
||||
function mt:NanDefault()
|
||||
local o = self.view:Offset(112)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
|
||||
end
|
||||
return nan
|
||||
end
|
||||
|
||||
function mt:InfDefault()
|
||||
local o = self.view:Offset(114)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
|
||||
end
|
||||
return inf
|
||||
end
|
||||
|
||||
function mt:PositiveInfDefault()
|
||||
local o = self.view:Offset(116)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
|
||||
end
|
||||
return inf
|
||||
end
|
||||
|
||||
function mt:InfinityDefault()
|
||||
local o = self.view:Offset(118)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
|
||||
end
|
||||
return inf
|
||||
end
|
||||
|
||||
function mt:PositiveInfinityDefault()
|
||||
local o = self.view:Offset(120)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
|
||||
end
|
||||
return inf
|
||||
end
|
||||
|
||||
function mt:NegativeInfDefault()
|
||||
local o = self.view:Offset(122)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
|
||||
end
|
||||
return -inf
|
||||
end
|
||||
|
||||
function mt:NegativeInfinityDefault()
|
||||
local o = self.view:Offset(124)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float32, self.view.pos + o)
|
||||
end
|
||||
return -inf
|
||||
end
|
||||
|
||||
function mt:DoubleInfDefault()
|
||||
local o = self.view:Offset(126)
|
||||
if o ~= 0 then
|
||||
return self.view:Get(flatbuffers.N.Float64, self.view.pos + o)
|
||||
end
|
||||
return inf
|
||||
end
|
||||
|
||||
function Monster.Start(builder)
|
||||
builder:StartObject(54)
|
||||
builder:StartObject(62)
|
||||
end
|
||||
|
||||
function Monster.AddPos(builder, pos)
|
||||
@@ -999,6 +1063,38 @@ function Monster.AddLongEnumNormalDefault(builder, longEnumNormalDefault)
|
||||
builder:PrependUint64Slot(53, longEnumNormalDefault, 2)
|
||||
end
|
||||
|
||||
function Monster.AddNanDefault(builder, nanDefault)
|
||||
builder:PrependFloat32Slot(54, nanDefault, nan)
|
||||
end
|
||||
|
||||
function Monster.AddInfDefault(builder, infDefault)
|
||||
builder:PrependFloat32Slot(55, infDefault, inf)
|
||||
end
|
||||
|
||||
function Monster.AddPositiveInfDefault(builder, positiveInfDefault)
|
||||
builder:PrependFloat32Slot(56, positiveInfDefault, inf)
|
||||
end
|
||||
|
||||
function Monster.AddInfinityDefault(builder, infinityDefault)
|
||||
builder:PrependFloat32Slot(57, infinityDefault, inf)
|
||||
end
|
||||
|
||||
function Monster.AddPositiveInfinityDefault(builder, positiveInfinityDefault)
|
||||
builder:PrependFloat32Slot(58, positiveInfinityDefault, inf)
|
||||
end
|
||||
|
||||
function Monster.AddNegativeInfDefault(builder, negativeInfDefault)
|
||||
builder:PrependFloat32Slot(59, negativeInfDefault, -inf)
|
||||
end
|
||||
|
||||
function Monster.AddNegativeInfinityDefault(builder, negativeInfinityDefault)
|
||||
builder:PrependFloat32Slot(60, negativeInfinityDefault, -inf)
|
||||
end
|
||||
|
||||
function Monster.AddDoubleInfDefault(builder, doubleInfDefault)
|
||||
builder:PrependFloat64Slot(61, doubleInfDefault, inf)
|
||||
end
|
||||
|
||||
function Monster.End(builder)
|
||||
return builder:EndObject()
|
||||
end
|
||||
|
||||
@@ -510,8 +510,64 @@ func longEnumNormalDefault*(self: Monster): MyGame_Example_LongEnum.LongEnum =
|
||||
return type(result)(2)
|
||||
func `longEnumNormalDefault=`*(self: var Monster, n: MyGame_Example_LongEnum.LongEnum): bool =
|
||||
return self.tab.MutateSlot(110, n)
|
||||
func nanDefault*(self: Monster): float32 =
|
||||
let o = self.tab.Offset(112)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return NaN
|
||||
func `nanDefault=`*(self: var Monster, n: float32): bool =
|
||||
return self.tab.MutateSlot(112, n)
|
||||
func infDefault*(self: Monster): float32 =
|
||||
let o = self.tab.Offset(114)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return Inf
|
||||
func `infDefault=`*(self: var Monster, n: float32): bool =
|
||||
return self.tab.MutateSlot(114, n)
|
||||
func positiveInfDefault*(self: Monster): float32 =
|
||||
let o = self.tab.Offset(116)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return Inf
|
||||
func `positiveInfDefault=`*(self: var Monster, n: float32): bool =
|
||||
return self.tab.MutateSlot(116, n)
|
||||
func infinityDefault*(self: Monster): float32 =
|
||||
let o = self.tab.Offset(118)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return Inf
|
||||
func `infinityDefault=`*(self: var Monster, n: float32): bool =
|
||||
return self.tab.MutateSlot(118, n)
|
||||
func positiveInfinityDefault*(self: Monster): float32 =
|
||||
let o = self.tab.Offset(120)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return Inf
|
||||
func `positiveInfinityDefault=`*(self: var Monster, n: float32): bool =
|
||||
return self.tab.MutateSlot(120, n)
|
||||
func negativeInfDefault*(self: Monster): float32 =
|
||||
let o = self.tab.Offset(122)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return -Inf
|
||||
func `negativeInfDefault=`*(self: var Monster, n: float32): bool =
|
||||
return self.tab.MutateSlot(122, n)
|
||||
func negativeInfinityDefault*(self: Monster): float32 =
|
||||
let o = self.tab.Offset(124)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return -Inf
|
||||
func `negativeInfinityDefault=`*(self: var Monster, n: float32): bool =
|
||||
return self.tab.MutateSlot(124, n)
|
||||
func doubleInfDefault*(self: Monster): float64 =
|
||||
let o = self.tab.Offset(126)
|
||||
if o != 0:
|
||||
return Get[float64](self.tab, self.tab.Pos + o)
|
||||
return Inf
|
||||
func `doubleInfDefault=`*(self: var Monster, n: float64): bool =
|
||||
return self.tab.MutateSlot(126, n)
|
||||
proc MonsterStart*(builder: var Builder) =
|
||||
builder.StartObject(54)
|
||||
builder.StartObject(62)
|
||||
proc MonsterAddpos*(builder: var Builder, pos: uoffset) =
|
||||
builder.PrependStructSlot(0, pos, default(uoffset))
|
||||
proc MonsterAddmana*(builder: var Builder, mana: int16) =
|
||||
@@ -658,5 +714,21 @@ proc MonsterAddlongEnumNonEnumDefault*(builder: var Builder, longEnumNonEnumDefa
|
||||
builder.PrependSlot(52, longEnumNonEnumDefault, default(uint64))
|
||||
proc MonsterAddlongEnumNormalDefault*(builder: var Builder, longEnumNormalDefault: uint64) =
|
||||
builder.PrependSlot(53, longEnumNormalDefault, default(uint64))
|
||||
proc MonsterAddnanDefault*(builder: var Builder, nanDefault: float32) =
|
||||
builder.PrependSlot(54, nanDefault, default(float32))
|
||||
proc MonsterAddinfDefault*(builder: var Builder, infDefault: float32) =
|
||||
builder.PrependSlot(55, infDefault, default(float32))
|
||||
proc MonsterAddpositiveInfDefault*(builder: var Builder, positiveInfDefault: float32) =
|
||||
builder.PrependSlot(56, positiveInfDefault, default(float32))
|
||||
proc MonsterAddinfinityDefault*(builder: var Builder, infinityDefault: float32) =
|
||||
builder.PrependSlot(57, infinityDefault, default(float32))
|
||||
proc MonsterAddpositiveInfinityDefault*(builder: var Builder, positiveInfinityDefault: float32) =
|
||||
builder.PrependSlot(58, positiveInfinityDefault, default(float32))
|
||||
proc MonsterAddnegativeInfDefault*(builder: var Builder, negativeInfDefault: float32) =
|
||||
builder.PrependSlot(59, negativeInfDefault, default(float32))
|
||||
proc MonsterAddnegativeInfinityDefault*(builder: var Builder, negativeInfinityDefault: float32) =
|
||||
builder.PrependSlot(60, negativeInfinityDefault, default(float32))
|
||||
proc MonsterAdddoubleInfDefault*(builder: var Builder, doubleInfDefault: float64) =
|
||||
builder.PrependSlot(61, doubleInfDefault, default(float64))
|
||||
proc MonsterEnd*(builder: var Builder): uoffset =
|
||||
return builder.EndObject()
|
||||
|
||||
@@ -754,22 +754,94 @@ class Monster extends Table
|
||||
return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : \MyGame\Example\LongEnum::LongOne;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return float
|
||||
*/
|
||||
public function getNanDefault()
|
||||
{
|
||||
$o = $this->__offset(112);
|
||||
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : nan;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return float
|
||||
*/
|
||||
public function getInfDefault()
|
||||
{
|
||||
$o = $this->__offset(114);
|
||||
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : inf;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return float
|
||||
*/
|
||||
public function getPositiveInfDefault()
|
||||
{
|
||||
$o = $this->__offset(116);
|
||||
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +inf;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return float
|
||||
*/
|
||||
public function getInfinityDefault()
|
||||
{
|
||||
$o = $this->__offset(118);
|
||||
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : infinity;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return float
|
||||
*/
|
||||
public function getPositiveInfinityDefault()
|
||||
{
|
||||
$o = $this->__offset(120);
|
||||
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : +infinity;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return float
|
||||
*/
|
||||
public function getNegativeInfDefault()
|
||||
{
|
||||
$o = $this->__offset(122);
|
||||
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -inf;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return float
|
||||
*/
|
||||
public function getNegativeInfinityDefault()
|
||||
{
|
||||
$o = $this->__offset(124);
|
||||
return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : -infinity;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return double
|
||||
*/
|
||||
public function getDoubleInfDefault()
|
||||
{
|
||||
$o = $this->__offset(126);
|
||||
return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : inf;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @return void
|
||||
*/
|
||||
public static function startMonster(FlatBufferBuilder $builder)
|
||||
{
|
||||
$builder->StartObject(54);
|
||||
$builder->StartObject(62);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @return Monster
|
||||
*/
|
||||
public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer, $scalar_key_sorted_tables, $native_inline, $long_enum_non_enum_default, $long_enum_normal_default)
|
||||
public static function createMonster(FlatBufferBuilder $builder, $pos, $mana, $hp, $name, $inventory, $color, $test_type, $test, $test4, $testarrayofstring, $testarrayoftables, $enemy, $testnestedflatbuffer, $testempty, $testbool, $testhashs32_fnv1, $testhashu32_fnv1, $testhashs64_fnv1, $testhashu64_fnv1, $testhashs32_fnv1a, $testhashu32_fnv1a, $testhashs64_fnv1a, $testhashu64_fnv1a, $testarrayofbools, $testf, $testf2, $testf3, $testarrayofstring2, $testarrayofsortedstruct, $flex, $test5, $vector_of_longs, $vector_of_doubles, $parent_namespace_test, $vector_of_referrables, $single_weak_reference, $vector_of_weak_references, $vector_of_strong_referrables, $co_owning_reference, $vector_of_co_owning_references, $non_owning_reference, $vector_of_non_owning_references, $any_unique_type, $any_unique, $any_ambiguous_type, $any_ambiguous, $vector_of_enums, $signed_enum, $testrequirednestedflatbuffer, $scalar_key_sorted_tables, $native_inline, $long_enum_non_enum_default, $long_enum_normal_default, $nan_default, $inf_default, $positive_inf_default, $infinity_default, $positive_infinity_default, $negative_inf_default, $negative_infinity_default, $double_inf_default)
|
||||
{
|
||||
$builder->startObject(54);
|
||||
$builder->startObject(62);
|
||||
self::addPos($builder, $pos);
|
||||
self::addMana($builder, $mana);
|
||||
self::addHp($builder, $hp);
|
||||
@@ -823,6 +895,14 @@ class Monster extends Table
|
||||
self::addNativeInline($builder, $native_inline);
|
||||
self::addLongEnumNonEnumDefault($builder, $long_enum_non_enum_default);
|
||||
self::addLongEnumNormalDefault($builder, $long_enum_normal_default);
|
||||
self::addNanDefault($builder, $nan_default);
|
||||
self::addInfDefault($builder, $inf_default);
|
||||
self::addPositiveInfDefault($builder, $positive_inf_default);
|
||||
self::addInfinityDefault($builder, $infinity_default);
|
||||
self::addPositiveInfinityDefault($builder, $positive_infinity_default);
|
||||
self::addNegativeInfDefault($builder, $negative_inf_default);
|
||||
self::addNegativeInfinityDefault($builder, $negative_infinity_default);
|
||||
self::addDoubleInfDefault($builder, $double_inf_default);
|
||||
$o = $builder->endObject();
|
||||
$builder->required($o, 10); // name
|
||||
return $o;
|
||||
@@ -1823,6 +1903,86 @@ class Monster extends Table
|
||||
$builder->addUlongX(53, $longEnumNormalDefault, 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param float
|
||||
* @return void
|
||||
*/
|
||||
public static function addNanDefault(FlatBufferBuilder $builder, $nanDefault)
|
||||
{
|
||||
$builder->addFloatX(54, $nanDefault, nan);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param float
|
||||
* @return void
|
||||
*/
|
||||
public static function addInfDefault(FlatBufferBuilder $builder, $infDefault)
|
||||
{
|
||||
$builder->addFloatX(55, $infDefault, inf);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param float
|
||||
* @return void
|
||||
*/
|
||||
public static function addPositiveInfDefault(FlatBufferBuilder $builder, $positiveInfDefault)
|
||||
{
|
||||
$builder->addFloatX(56, $positiveInfDefault, +inf);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param float
|
||||
* @return void
|
||||
*/
|
||||
public static function addInfinityDefault(FlatBufferBuilder $builder, $infinityDefault)
|
||||
{
|
||||
$builder->addFloatX(57, $infinityDefault, infinity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param float
|
||||
* @return void
|
||||
*/
|
||||
public static function addPositiveInfinityDefault(FlatBufferBuilder $builder, $positiveInfinityDefault)
|
||||
{
|
||||
$builder->addFloatX(58, $positiveInfinityDefault, +infinity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param float
|
||||
* @return void
|
||||
*/
|
||||
public static function addNegativeInfDefault(FlatBufferBuilder $builder, $negativeInfDefault)
|
||||
{
|
||||
$builder->addFloatX(59, $negativeInfDefault, -inf);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param float
|
||||
* @return void
|
||||
*/
|
||||
public static function addNegativeInfinityDefault(FlatBufferBuilder $builder, $negativeInfinityDefault)
|
||||
{
|
||||
$builder->addFloatX(60, $negativeInfinityDefault, -infinity);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @param double
|
||||
* @return void
|
||||
*/
|
||||
public static function addDoubleInfDefault(FlatBufferBuilder $builder, $doubleInfDefault)
|
||||
{
|
||||
$builder->addDoubleX(61, $doubleInfDefault, inf);
|
||||
}
|
||||
|
||||
/**
|
||||
* @param FlatBufferBuilder $builder
|
||||
* @return int table offset
|
||||
|
||||
@@ -816,7 +816,63 @@ class Monster(object):
|
||||
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
||||
return 2
|
||||
|
||||
def MonsterStart(builder): builder.StartObject(54)
|
||||
# Monster
|
||||
def NanDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(112))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return float('nan')
|
||||
|
||||
# Monster
|
||||
def InfDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(114))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return float('inf')
|
||||
|
||||
# Monster
|
||||
def PositiveInfDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(116))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return float('inf')
|
||||
|
||||
# Monster
|
||||
def InfinityDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(118))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return float('inf')
|
||||
|
||||
# Monster
|
||||
def PositiveInfinityDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(120))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return float('inf')
|
||||
|
||||
# Monster
|
||||
def NegativeInfDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(122))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return float('-inf')
|
||||
|
||||
# Monster
|
||||
def NegativeInfinityDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(124))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return float('-inf')
|
||||
|
||||
# Monster
|
||||
def DoubleInfDefault(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(126))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
||||
return float('inf')
|
||||
|
||||
def MonsterStart(builder): builder.StartObject(62)
|
||||
def Start(builder):
|
||||
return MonsterStart(builder)
|
||||
def MonsterAddPos(builder, pos): builder.PrependStructSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(pos), 0)
|
||||
@@ -1052,6 +1108,30 @@ def AddLongEnumNonEnumDefault(builder, longEnumNonEnumDefault):
|
||||
def MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault): builder.PrependUint64Slot(53, longEnumNormalDefault, 2)
|
||||
def AddLongEnumNormalDefault(builder, longEnumNormalDefault):
|
||||
return MonsterAddLongEnumNormalDefault(builder, longEnumNormalDefault)
|
||||
def MonsterAddNanDefault(builder, nanDefault): builder.PrependFloat32Slot(54, nanDefault, float('nan'))
|
||||
def AddNanDefault(builder, nanDefault):
|
||||
return MonsterAddNanDefault(builder, nanDefault)
|
||||
def MonsterAddInfDefault(builder, infDefault): builder.PrependFloat32Slot(55, infDefault, float('inf'))
|
||||
def AddInfDefault(builder, infDefault):
|
||||
return MonsterAddInfDefault(builder, infDefault)
|
||||
def MonsterAddPositiveInfDefault(builder, positiveInfDefault): builder.PrependFloat32Slot(56, positiveInfDefault, float('inf'))
|
||||
def AddPositiveInfDefault(builder, positiveInfDefault):
|
||||
return MonsterAddPositiveInfDefault(builder, positiveInfDefault)
|
||||
def MonsterAddInfinityDefault(builder, infinityDefault): builder.PrependFloat32Slot(57, infinityDefault, float('inf'))
|
||||
def AddInfinityDefault(builder, infinityDefault):
|
||||
return MonsterAddInfinityDefault(builder, infinityDefault)
|
||||
def MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault): builder.PrependFloat32Slot(58, positiveInfinityDefault, float('inf'))
|
||||
def AddPositiveInfinityDefault(builder, positiveInfinityDefault):
|
||||
return MonsterAddPositiveInfinityDefault(builder, positiveInfinityDefault)
|
||||
def MonsterAddNegativeInfDefault(builder, negativeInfDefault): builder.PrependFloat32Slot(59, negativeInfDefault, float('-inf'))
|
||||
def AddNegativeInfDefault(builder, negativeInfDefault):
|
||||
return MonsterAddNegativeInfDefault(builder, negativeInfDefault)
|
||||
def MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault): builder.PrependFloat32Slot(60, negativeInfinityDefault, float('-inf'))
|
||||
def AddNegativeInfinityDefault(builder, negativeInfinityDefault):
|
||||
return MonsterAddNegativeInfinityDefault(builder, negativeInfinityDefault)
|
||||
def MonsterAddDoubleInfDefault(builder, doubleInfDefault): builder.PrependFloat64Slot(61, doubleInfDefault, float('inf'))
|
||||
def AddDoubleInfDefault(builder, doubleInfDefault):
|
||||
return MonsterAddDoubleInfDefault(builder, doubleInfDefault)
|
||||
def MonsterEnd(builder): return builder.EndObject()
|
||||
def End(builder):
|
||||
return MonsterEnd(builder)
|
||||
@@ -1128,6 +1208,14 @@ class MonsterT(object):
|
||||
self.nativeInline = None # type: Optional[MyGame.Example.Test.TestT]
|
||||
self.longEnumNonEnumDefault = 0 # type: int
|
||||
self.longEnumNormalDefault = 2 # type: int
|
||||
self.nanDefault = float('nan') # type: float
|
||||
self.infDefault = float('inf') # type: float
|
||||
self.positiveInfDefault = float('inf') # type: float
|
||||
self.infinityDefault = float('inf') # type: float
|
||||
self.positiveInfinityDefault = float('inf') # type: float
|
||||
self.negativeInfDefault = float('-inf') # type: float
|
||||
self.negativeInfinityDefault = float('-inf') # type: float
|
||||
self.doubleInfDefault = float('inf') # type: float
|
||||
|
||||
@classmethod
|
||||
def InitFromBuf(cls, buf, pos):
|
||||
@@ -1329,6 +1417,14 @@ class MonsterT(object):
|
||||
self.nativeInline = MyGame.Example.Test.TestT.InitFromObj(monster.NativeInline())
|
||||
self.longEnumNonEnumDefault = monster.LongEnumNonEnumDefault()
|
||||
self.longEnumNormalDefault = monster.LongEnumNormalDefault()
|
||||
self.nanDefault = monster.NanDefault()
|
||||
self.infDefault = monster.InfDefault()
|
||||
self.positiveInfDefault = monster.PositiveInfDefault()
|
||||
self.infinityDefault = monster.InfinityDefault()
|
||||
self.positiveInfinityDefault = monster.PositiveInfinityDefault()
|
||||
self.negativeInfDefault = monster.NegativeInfDefault()
|
||||
self.negativeInfinityDefault = monster.NegativeInfinityDefault()
|
||||
self.doubleInfDefault = monster.DoubleInfDefault()
|
||||
|
||||
# MonsterT
|
||||
def Pack(self, builder):
|
||||
@@ -1582,5 +1678,13 @@ class MonsterT(object):
|
||||
MonsterAddNativeInline(builder, nativeInline)
|
||||
MonsterAddLongEnumNonEnumDefault(builder, self.longEnumNonEnumDefault)
|
||||
MonsterAddLongEnumNormalDefault(builder, self.longEnumNormalDefault)
|
||||
MonsterAddNanDefault(builder, self.nanDefault)
|
||||
MonsterAddInfDefault(builder, self.infDefault)
|
||||
MonsterAddPositiveInfDefault(builder, self.positiveInfDefault)
|
||||
MonsterAddInfinityDefault(builder, self.infinityDefault)
|
||||
MonsterAddPositiveInfinityDefault(builder, self.positiveInfinityDefault)
|
||||
MonsterAddNegativeInfDefault(builder, self.negativeInfDefault)
|
||||
MonsterAddNegativeInfinityDefault(builder, self.negativeInfinityDefault)
|
||||
MonsterAddDoubleInfDefault(builder, self.doubleInfDefault)
|
||||
monster = MonsterEnd(builder)
|
||||
return monster
|
||||
|
||||
@@ -58,6 +58,14 @@ public class MonsterT {
|
||||
private MyGame.Example.TestT nativeInline;
|
||||
private long longEnumNonEnumDefault;
|
||||
private long longEnumNormalDefault;
|
||||
private float nanDefault;
|
||||
private float infDefault;
|
||||
private float positiveInfDefault;
|
||||
private float infinityDefault;
|
||||
private float positiveInfinityDefault;
|
||||
private float negativeInfDefault;
|
||||
private float negativeInfinityDefault;
|
||||
private double doubleInfDefault;
|
||||
|
||||
public MyGame.Example.Vec3T getPos() { return pos; }
|
||||
|
||||
@@ -259,6 +267,38 @@ public class MonsterT {
|
||||
|
||||
public void setLongEnumNormalDefault(long longEnumNormalDefault) { this.longEnumNormalDefault = longEnumNormalDefault; }
|
||||
|
||||
public float getNanDefault() { return nanDefault; }
|
||||
|
||||
public void setNanDefault(float nanDefault) { this.nanDefault = nanDefault; }
|
||||
|
||||
public float getInfDefault() { return infDefault; }
|
||||
|
||||
public void setInfDefault(float infDefault) { this.infDefault = infDefault; }
|
||||
|
||||
public float getPositiveInfDefault() { return positiveInfDefault; }
|
||||
|
||||
public void setPositiveInfDefault(float positiveInfDefault) { this.positiveInfDefault = positiveInfDefault; }
|
||||
|
||||
public float getInfinityDefault() { return infinityDefault; }
|
||||
|
||||
public void setInfinityDefault(float infinityDefault) { this.infinityDefault = infinityDefault; }
|
||||
|
||||
public float getPositiveInfinityDefault() { return positiveInfinityDefault; }
|
||||
|
||||
public void setPositiveInfinityDefault(float positiveInfinityDefault) { this.positiveInfinityDefault = positiveInfinityDefault; }
|
||||
|
||||
public float getNegativeInfDefault() { return negativeInfDefault; }
|
||||
|
||||
public void setNegativeInfDefault(float negativeInfDefault) { this.negativeInfDefault = negativeInfDefault; }
|
||||
|
||||
public float getNegativeInfinityDefault() { return negativeInfinityDefault; }
|
||||
|
||||
public void setNegativeInfinityDefault(float negativeInfinityDefault) { this.negativeInfinityDefault = negativeInfinityDefault; }
|
||||
|
||||
public double getDoubleInfDefault() { return doubleInfDefault; }
|
||||
|
||||
public void setDoubleInfDefault(double doubleInfDefault) { this.doubleInfDefault = doubleInfDefault; }
|
||||
|
||||
|
||||
public MonsterT() {
|
||||
this.pos = new MyGame.Example.Vec3T();
|
||||
@@ -311,6 +351,14 @@ public class MonsterT {
|
||||
this.nativeInline = new MyGame.Example.TestT();
|
||||
this.longEnumNonEnumDefault = 0L;
|
||||
this.longEnumNormalDefault = 2L;
|
||||
this.nanDefault = Float.NaN;
|
||||
this.infDefault = Float.POSITIVE_INFINITY;
|
||||
this.positiveInfDefault = Float.POSITIVE_INFINITY;
|
||||
this.infinityDefault = Float.POSITIVE_INFINITY;
|
||||
this.positiveInfinityDefault = Float.POSITIVE_INFINITY;
|
||||
this.negativeInfDefault = Float.NEGATIVE_INFINITY;
|
||||
this.negativeInfinityDefault = Float.NEGATIVE_INFINITY;
|
||||
this.doubleInfDefault = Double.POSITIVE_INFINITY;
|
||||
}
|
||||
public static MonsterT deserializeFromBinary(byte[] fbBuffer) {
|
||||
return Monster.getRootAsMonster(ByteBuffer.wrap(fbBuffer)).unpack();
|
||||
|
||||
Reference in New Issue
Block a user