Merge commit '0f6aab9da6fe982218a01f4a5b896e65fcced437' as 'third_party/flatbuffers'
This commit is contained in:
Siarhei Fedartsou
@@ -0,0 +1,16 @@
|
||||
// <auto-generated>
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
// </auto-generated>
|
||||
|
||||
namespace optional_scalars
|
||||
{
|
||||
|
||||
public enum OptionalByte : sbyte
|
||||
{
|
||||
None = 0,
|
||||
One = 1,
|
||||
Two = 2,
|
||||
};
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package optional_scalars
|
||||
|
||||
import "strconv"
|
||||
|
||||
type OptionalByte int8
|
||||
|
||||
const (
|
||||
OptionalByteNone OptionalByte = 0
|
||||
OptionalByteOne OptionalByte = 1
|
||||
OptionalByteTwo OptionalByte = 2
|
||||
)
|
||||
|
||||
var EnumNamesOptionalByte = map[OptionalByte]string{
|
||||
OptionalByteNone: "None",
|
||||
OptionalByteOne: "One",
|
||||
OptionalByteTwo: "Two",
|
||||
}
|
||||
|
||||
var EnumValuesOptionalByte = map[string]OptionalByte{
|
||||
"None": OptionalByteNone,
|
||||
"One": OptionalByteOne,
|
||||
"Two": OptionalByteTwo,
|
||||
}
|
||||
|
||||
func (v OptionalByte) String() string {
|
||||
if s, ok := EnumNamesOptionalByte[v]; ok {
|
||||
return s
|
||||
}
|
||||
return "OptionalByte(" + strconv.FormatInt(int64(v), 10) + ")"
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
package optional_scalars;
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public final class OptionalByte {
|
||||
private OptionalByte() { }
|
||||
public static final byte None = 0;
|
||||
public static final byte One = 1;
|
||||
public static final byte Two = 2;
|
||||
|
||||
public static final String[] names = { "None", "One", "Two", };
|
||||
|
||||
public static String name(int e) { return names[e]; }
|
||||
}
|
||||
|
||||
@@ -0,0 +1,12 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
package optional_scalars
|
||||
|
||||
@Suppress("unused")
|
||||
class OptionalByte private constructor() {
|
||||
companion object {
|
||||
const val None: Byte = 0
|
||||
const val One: Byte = 1
|
||||
const val Two: Byte = 2
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
#[ optional_scalars.OptionalByte
|
||||
Automatically generated by the FlatBuffers compiler, do not modify.
|
||||
Or modify. I'm a message, not a cop.
|
||||
|
||||
flatc version: 24.3.25
|
||||
|
||||
Declared by :
|
||||
Rooting type : optional_scalars.ScalarStuff ()
|
||||
]#
|
||||
|
||||
type OptionalByte*{.pure.} = enum
|
||||
None = 0.int8,
|
||||
One = 1.int8,
|
||||
Two = 2.int8,
|
||||
@@ -0,0 +1,8 @@
|
||||
# automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
# namespace: optional_scalars
|
||||
|
||||
class OptionalByte(object):
|
||||
None_ = 0
|
||||
One = 1
|
||||
Two = 2
|
||||
@@ -0,0 +1,400 @@
|
||||
// <auto-generated>
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
// </auto-generated>
|
||||
|
||||
namespace optional_scalars
|
||||
{
|
||||
|
||||
using global::System;
|
||||
using global::System.Collections.Generic;
|
||||
using global::Google.FlatBuffers;
|
||||
|
||||
public struct ScalarStuff : IFlatbufferObject
|
||||
{
|
||||
private Table __p;
|
||||
public ByteBuffer ByteBuffer { get { return __p.bb; } }
|
||||
public static void ValidateVersion() { FlatBufferConstants.FLATBUFFERS_24_3_25(); }
|
||||
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb) { return GetRootAsScalarStuff(_bb, new ScalarStuff()); }
|
||||
public static ScalarStuff GetRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); }
|
||||
public static bool ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return Table.__has_identifier(_bb, "NULL"); }
|
||||
public static bool VerifyScalarStuff(ByteBuffer _bb) {Google.FlatBuffers.Verifier verifier = new Google.FlatBuffers.Verifier(_bb); return verifier.VerifyBuffer("NULL", false, ScalarStuffVerify.Verify); }
|
||||
public void __init(int _i, ByteBuffer _bb) { __p = new Table(_i, _bb); }
|
||||
public ScalarStuff __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
|
||||
|
||||
public sbyte JustI8 { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetSbyte(o + __p.bb_pos) : (sbyte)0; } }
|
||||
public sbyte? MaybeI8 { get { int o = __p.__offset(6); return o != 0 ? __p.bb.GetSbyte(o + __p.bb_pos) : (sbyte?)null; } }
|
||||
public sbyte DefaultI8 { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetSbyte(o + __p.bb_pos) : (sbyte)42; } }
|
||||
public byte JustU8 { get { int o = __p.__offset(10); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } }
|
||||
public byte? MaybeU8 { get { int o = __p.__offset(12); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte?)null; } }
|
||||
public byte DefaultU8 { get { int o = __p.__offset(14); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)42; } }
|
||||
public short JustI16 { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetShort(o + __p.bb_pos) : (short)0; } }
|
||||
public short? MaybeI16 { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetShort(o + __p.bb_pos) : (short?)null; } }
|
||||
public short DefaultI16 { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetShort(o + __p.bb_pos) : (short)42; } }
|
||||
public ushort JustU16 { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)0; } }
|
||||
public ushort? MaybeU16 { get { int o = __p.__offset(24); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort?)null; } }
|
||||
public ushort DefaultU16 { get { int o = __p.__offset(26); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)42; } }
|
||||
public int JustI32 { get { int o = __p.__offset(28); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } }
|
||||
public int? MaybeI32 { get { int o = __p.__offset(30); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int?)null; } }
|
||||
public int DefaultI32 { get { int o = __p.__offset(32); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)42; } }
|
||||
public uint JustU32 { get { int o = __p.__offset(34); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } }
|
||||
public uint? MaybeU32 { get { int o = __p.__offset(36); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint?)null; } }
|
||||
public uint DefaultU32 { get { int o = __p.__offset(38); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)42; } }
|
||||
public long JustI64 { get { int o = __p.__offset(40); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } }
|
||||
public long? MaybeI64 { get { int o = __p.__offset(42); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long?)null; } }
|
||||
public long DefaultI64 { get { int o = __p.__offset(44); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)42; } }
|
||||
public ulong JustU64 { get { int o = __p.__offset(46); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong)0; } }
|
||||
public ulong? MaybeU64 { get { int o = __p.__offset(48); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong?)null; } }
|
||||
public ulong DefaultU64 { get { int o = __p.__offset(50); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong)42; } }
|
||||
public float JustF32 { get { int o = __p.__offset(52); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } }
|
||||
public float? MaybeF32 { get { int o = __p.__offset(54); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float?)null; } }
|
||||
public float DefaultF32 { get { int o = __p.__offset(56); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)42.0f; } }
|
||||
public double JustF64 { get { int o = __p.__offset(58); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } }
|
||||
public double? MaybeF64 { get { int o = __p.__offset(60); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double?)null; } }
|
||||
public double DefaultF64 { get { int o = __p.__offset(62); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)42.0; } }
|
||||
public bool JustBool { get { int o = __p.__offset(64); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)false; } }
|
||||
public bool? MaybeBool { get { int o = __p.__offset(66); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool?)null; } }
|
||||
public bool DefaultBool { get { int o = __p.__offset(68); return o != 0 ? 0!=__p.bb.Get(o + __p.bb_pos) : (bool)true; } }
|
||||
public optional_scalars.OptionalByte JustEnum { get { int o = __p.__offset(70); return o != 0 ? (optional_scalars.OptionalByte)__p.bb.GetSbyte(o + __p.bb_pos) : optional_scalars.OptionalByte.None; } }
|
||||
public optional_scalars.OptionalByte? MaybeEnum { get { int o = __p.__offset(72); return o != 0 ? (optional_scalars.OptionalByte)__p.bb.GetSbyte(o + __p.bb_pos) : (optional_scalars.OptionalByte?)null; } }
|
||||
public optional_scalars.OptionalByte DefaultEnum { get { int o = __p.__offset(74); return o != 0 ? (optional_scalars.OptionalByte)__p.bb.GetSbyte(o + __p.bb_pos) : optional_scalars.OptionalByte.One; } }
|
||||
|
||||
public static Offset<optional_scalars.ScalarStuff> CreateScalarStuff(FlatBufferBuilder builder,
|
||||
sbyte just_i8 = 0,
|
||||
sbyte? maybe_i8 = null,
|
||||
sbyte default_i8 = 42,
|
||||
byte just_u8 = 0,
|
||||
byte? maybe_u8 = null,
|
||||
byte default_u8 = 42,
|
||||
short just_i16 = 0,
|
||||
short? maybe_i16 = null,
|
||||
short default_i16 = 42,
|
||||
ushort just_u16 = 0,
|
||||
ushort? maybe_u16 = null,
|
||||
ushort default_u16 = 42,
|
||||
int just_i32 = 0,
|
||||
int? maybe_i32 = null,
|
||||
int default_i32 = 42,
|
||||
uint just_u32 = 0,
|
||||
uint? maybe_u32 = null,
|
||||
uint default_u32 = 42,
|
||||
long just_i64 = 0,
|
||||
long? maybe_i64 = null,
|
||||
long default_i64 = 42,
|
||||
ulong just_u64 = 0,
|
||||
ulong? maybe_u64 = null,
|
||||
ulong default_u64 = 42,
|
||||
float just_f32 = 0.0f,
|
||||
float? maybe_f32 = null,
|
||||
float default_f32 = 42.0f,
|
||||
double just_f64 = 0.0,
|
||||
double? maybe_f64 = null,
|
||||
double default_f64 = 42.0,
|
||||
bool just_bool = false,
|
||||
bool? maybe_bool = null,
|
||||
bool default_bool = true,
|
||||
optional_scalars.OptionalByte just_enum = optional_scalars.OptionalByte.None,
|
||||
optional_scalars.OptionalByte? maybe_enum = null,
|
||||
optional_scalars.OptionalByte default_enum = optional_scalars.OptionalByte.One) {
|
||||
builder.StartTable(36);
|
||||
ScalarStuff.AddDefaultF64(builder, default_f64);
|
||||
ScalarStuff.AddMaybeF64(builder, maybe_f64);
|
||||
ScalarStuff.AddJustF64(builder, just_f64);
|
||||
ScalarStuff.AddDefaultU64(builder, default_u64);
|
||||
ScalarStuff.AddMaybeU64(builder, maybe_u64);
|
||||
ScalarStuff.AddJustU64(builder, just_u64);
|
||||
ScalarStuff.AddDefaultI64(builder, default_i64);
|
||||
ScalarStuff.AddMaybeI64(builder, maybe_i64);
|
||||
ScalarStuff.AddJustI64(builder, just_i64);
|
||||
ScalarStuff.AddDefaultF32(builder, default_f32);
|
||||
ScalarStuff.AddMaybeF32(builder, maybe_f32);
|
||||
ScalarStuff.AddJustF32(builder, just_f32);
|
||||
ScalarStuff.AddDefaultU32(builder, default_u32);
|
||||
ScalarStuff.AddMaybeU32(builder, maybe_u32);
|
||||
ScalarStuff.AddJustU32(builder, just_u32);
|
||||
ScalarStuff.AddDefaultI32(builder, default_i32);
|
||||
ScalarStuff.AddMaybeI32(builder, maybe_i32);
|
||||
ScalarStuff.AddJustI32(builder, just_i32);
|
||||
ScalarStuff.AddDefaultU16(builder, default_u16);
|
||||
ScalarStuff.AddMaybeU16(builder, maybe_u16);
|
||||
ScalarStuff.AddJustU16(builder, just_u16);
|
||||
ScalarStuff.AddDefaultI16(builder, default_i16);
|
||||
ScalarStuff.AddMaybeI16(builder, maybe_i16);
|
||||
ScalarStuff.AddJustI16(builder, just_i16);
|
||||
ScalarStuff.AddDefaultEnum(builder, default_enum);
|
||||
ScalarStuff.AddMaybeEnum(builder, maybe_enum);
|
||||
ScalarStuff.AddJustEnum(builder, just_enum);
|
||||
ScalarStuff.AddDefaultBool(builder, default_bool);
|
||||
ScalarStuff.AddMaybeBool(builder, maybe_bool);
|
||||
ScalarStuff.AddJustBool(builder, just_bool);
|
||||
ScalarStuff.AddDefaultU8(builder, default_u8);
|
||||
ScalarStuff.AddMaybeU8(builder, maybe_u8);
|
||||
ScalarStuff.AddJustU8(builder, just_u8);
|
||||
ScalarStuff.AddDefaultI8(builder, default_i8);
|
||||
ScalarStuff.AddMaybeI8(builder, maybe_i8);
|
||||
ScalarStuff.AddJustI8(builder, just_i8);
|
||||
return ScalarStuff.EndScalarStuff(builder);
|
||||
}
|
||||
|
||||
public static void StartScalarStuff(FlatBufferBuilder builder) { builder.StartTable(36); }
|
||||
public static void AddJustI8(FlatBufferBuilder builder, sbyte justI8) { builder.AddSbyte(0, justI8, 0); }
|
||||
public static void AddMaybeI8(FlatBufferBuilder builder, sbyte? maybeI8) { builder.AddSbyte(1, maybeI8); }
|
||||
public static void AddDefaultI8(FlatBufferBuilder builder, sbyte defaultI8) { builder.AddSbyte(2, defaultI8, 42); }
|
||||
public static void AddJustU8(FlatBufferBuilder builder, byte justU8) { builder.AddByte(3, justU8, 0); }
|
||||
public static void AddMaybeU8(FlatBufferBuilder builder, byte? maybeU8) { builder.AddByte(4, maybeU8); }
|
||||
public static void AddDefaultU8(FlatBufferBuilder builder, byte defaultU8) { builder.AddByte(5, defaultU8, 42); }
|
||||
public static void AddJustI16(FlatBufferBuilder builder, short justI16) { builder.AddShort(6, justI16, 0); }
|
||||
public static void AddMaybeI16(FlatBufferBuilder builder, short? maybeI16) { builder.AddShort(7, maybeI16); }
|
||||
public static void AddDefaultI16(FlatBufferBuilder builder, short defaultI16) { builder.AddShort(8, defaultI16, 42); }
|
||||
public static void AddJustU16(FlatBufferBuilder builder, ushort justU16) { builder.AddUshort(9, justU16, 0); }
|
||||
public static void AddMaybeU16(FlatBufferBuilder builder, ushort? maybeU16) { builder.AddUshort(10, maybeU16); }
|
||||
public static void AddDefaultU16(FlatBufferBuilder builder, ushort defaultU16) { builder.AddUshort(11, defaultU16, 42); }
|
||||
public static void AddJustI32(FlatBufferBuilder builder, int justI32) { builder.AddInt(12, justI32, 0); }
|
||||
public static void AddMaybeI32(FlatBufferBuilder builder, int? maybeI32) { builder.AddInt(13, maybeI32); }
|
||||
public static void AddDefaultI32(FlatBufferBuilder builder, int defaultI32) { builder.AddInt(14, defaultI32, 42); }
|
||||
public static void AddJustU32(FlatBufferBuilder builder, uint justU32) { builder.AddUint(15, justU32, 0); }
|
||||
public static void AddMaybeU32(FlatBufferBuilder builder, uint? maybeU32) { builder.AddUint(16, maybeU32); }
|
||||
public static void AddDefaultU32(FlatBufferBuilder builder, uint defaultU32) { builder.AddUint(17, defaultU32, 42); }
|
||||
public static void AddJustI64(FlatBufferBuilder builder, long justI64) { builder.AddLong(18, justI64, 0); }
|
||||
public static void AddMaybeI64(FlatBufferBuilder builder, long? maybeI64) { builder.AddLong(19, maybeI64); }
|
||||
public static void AddDefaultI64(FlatBufferBuilder builder, long defaultI64) { builder.AddLong(20, defaultI64, 42); }
|
||||
public static void AddJustU64(FlatBufferBuilder builder, ulong justU64) { builder.AddUlong(21, justU64, 0); }
|
||||
public static void AddMaybeU64(FlatBufferBuilder builder, ulong? maybeU64) { builder.AddUlong(22, maybeU64); }
|
||||
public static void AddDefaultU64(FlatBufferBuilder builder, ulong defaultU64) { builder.AddUlong(23, defaultU64, 42); }
|
||||
public static void AddJustF32(FlatBufferBuilder builder, float justF32) { builder.AddFloat(24, justF32, 0.0f); }
|
||||
public static void AddMaybeF32(FlatBufferBuilder builder, float? maybeF32) { builder.AddFloat(25, maybeF32); }
|
||||
public static void AddDefaultF32(FlatBufferBuilder builder, float defaultF32) { builder.AddFloat(26, defaultF32, 42.0f); }
|
||||
public static void AddJustF64(FlatBufferBuilder builder, double justF64) { builder.AddDouble(27, justF64, 0.0); }
|
||||
public static void AddMaybeF64(FlatBufferBuilder builder, double? maybeF64) { builder.AddDouble(28, maybeF64); }
|
||||
public static void AddDefaultF64(FlatBufferBuilder builder, double defaultF64) { builder.AddDouble(29, defaultF64, 42.0); }
|
||||
public static void AddJustBool(FlatBufferBuilder builder, bool justBool) { builder.AddBool(30, justBool, false); }
|
||||
public static void AddMaybeBool(FlatBufferBuilder builder, bool? maybeBool) { builder.AddBool(31, maybeBool); }
|
||||
public static void AddDefaultBool(FlatBufferBuilder builder, bool defaultBool) { builder.AddBool(32, defaultBool, true); }
|
||||
public static void AddJustEnum(FlatBufferBuilder builder, optional_scalars.OptionalByte justEnum) { builder.AddSbyte(33, (sbyte)justEnum, 0); }
|
||||
public static void AddMaybeEnum(FlatBufferBuilder builder, optional_scalars.OptionalByte? maybeEnum) { builder.AddSbyte(34, (sbyte?)maybeEnum); }
|
||||
public static void AddDefaultEnum(FlatBufferBuilder builder, optional_scalars.OptionalByte defaultEnum) { builder.AddSbyte(35, (sbyte)defaultEnum, 1); }
|
||||
public static Offset<optional_scalars.ScalarStuff> EndScalarStuff(FlatBufferBuilder builder) {
|
||||
int o = builder.EndTable();
|
||||
return new Offset<optional_scalars.ScalarStuff>(o);
|
||||
}
|
||||
public static void FinishScalarStuffBuffer(FlatBufferBuilder builder, Offset<optional_scalars.ScalarStuff> offset) { builder.Finish(offset.Value, "NULL"); }
|
||||
public static void FinishSizePrefixedScalarStuffBuffer(FlatBufferBuilder builder, Offset<optional_scalars.ScalarStuff> offset) { builder.FinishSizePrefixed(offset.Value, "NULL"); }
|
||||
public ScalarStuffT UnPack() {
|
||||
var _o = new ScalarStuffT();
|
||||
this.UnPackTo(_o);
|
||||
return _o;
|
||||
}
|
||||
public void UnPackTo(ScalarStuffT _o) {
|
||||
_o.JustI8 = this.JustI8;
|
||||
_o.MaybeI8 = this.MaybeI8;
|
||||
_o.DefaultI8 = this.DefaultI8;
|
||||
_o.JustU8 = this.JustU8;
|
||||
_o.MaybeU8 = this.MaybeU8;
|
||||
_o.DefaultU8 = this.DefaultU8;
|
||||
_o.JustI16 = this.JustI16;
|
||||
_o.MaybeI16 = this.MaybeI16;
|
||||
_o.DefaultI16 = this.DefaultI16;
|
||||
_o.JustU16 = this.JustU16;
|
||||
_o.MaybeU16 = this.MaybeU16;
|
||||
_o.DefaultU16 = this.DefaultU16;
|
||||
_o.JustI32 = this.JustI32;
|
||||
_o.MaybeI32 = this.MaybeI32;
|
||||
_o.DefaultI32 = this.DefaultI32;
|
||||
_o.JustU32 = this.JustU32;
|
||||
_o.MaybeU32 = this.MaybeU32;
|
||||
_o.DefaultU32 = this.DefaultU32;
|
||||
_o.JustI64 = this.JustI64;
|
||||
_o.MaybeI64 = this.MaybeI64;
|
||||
_o.DefaultI64 = this.DefaultI64;
|
||||
_o.JustU64 = this.JustU64;
|
||||
_o.MaybeU64 = this.MaybeU64;
|
||||
_o.DefaultU64 = this.DefaultU64;
|
||||
_o.JustF32 = this.JustF32;
|
||||
_o.MaybeF32 = this.MaybeF32;
|
||||
_o.DefaultF32 = this.DefaultF32;
|
||||
_o.JustF64 = this.JustF64;
|
||||
_o.MaybeF64 = this.MaybeF64;
|
||||
_o.DefaultF64 = this.DefaultF64;
|
||||
_o.JustBool = this.JustBool;
|
||||
_o.MaybeBool = this.MaybeBool;
|
||||
_o.DefaultBool = this.DefaultBool;
|
||||
_o.JustEnum = this.JustEnum;
|
||||
_o.MaybeEnum = this.MaybeEnum;
|
||||
_o.DefaultEnum = this.DefaultEnum;
|
||||
}
|
||||
public static Offset<optional_scalars.ScalarStuff> Pack(FlatBufferBuilder builder, ScalarStuffT _o) {
|
||||
if (_o == null) return default(Offset<optional_scalars.ScalarStuff>);
|
||||
return CreateScalarStuff(
|
||||
builder,
|
||||
_o.JustI8,
|
||||
_o.MaybeI8,
|
||||
_o.DefaultI8,
|
||||
_o.JustU8,
|
||||
_o.MaybeU8,
|
||||
_o.DefaultU8,
|
||||
_o.JustI16,
|
||||
_o.MaybeI16,
|
||||
_o.DefaultI16,
|
||||
_o.JustU16,
|
||||
_o.MaybeU16,
|
||||
_o.DefaultU16,
|
||||
_o.JustI32,
|
||||
_o.MaybeI32,
|
||||
_o.DefaultI32,
|
||||
_o.JustU32,
|
||||
_o.MaybeU32,
|
||||
_o.DefaultU32,
|
||||
_o.JustI64,
|
||||
_o.MaybeI64,
|
||||
_o.DefaultI64,
|
||||
_o.JustU64,
|
||||
_o.MaybeU64,
|
||||
_o.DefaultU64,
|
||||
_o.JustF32,
|
||||
_o.MaybeF32,
|
||||
_o.DefaultF32,
|
||||
_o.JustF64,
|
||||
_o.MaybeF64,
|
||||
_o.DefaultF64,
|
||||
_o.JustBool,
|
||||
_o.MaybeBool,
|
||||
_o.DefaultBool,
|
||||
_o.JustEnum,
|
||||
_o.MaybeEnum,
|
||||
_o.DefaultEnum);
|
||||
}
|
||||
}
|
||||
|
||||
public class ScalarStuffT
|
||||
{
|
||||
public sbyte JustI8 { get; set; }
|
||||
public sbyte? MaybeI8 { get; set; }
|
||||
public sbyte DefaultI8 { get; set; }
|
||||
public byte JustU8 { get; set; }
|
||||
public byte? MaybeU8 { get; set; }
|
||||
public byte DefaultU8 { get; set; }
|
||||
public short JustI16 { get; set; }
|
||||
public short? MaybeI16 { get; set; }
|
||||
public short DefaultI16 { get; set; }
|
||||
public ushort JustU16 { get; set; }
|
||||
public ushort? MaybeU16 { get; set; }
|
||||
public ushort DefaultU16 { get; set; }
|
||||
public int JustI32 { get; set; }
|
||||
public int? MaybeI32 { get; set; }
|
||||
public int DefaultI32 { get; set; }
|
||||
public uint JustU32 { get; set; }
|
||||
public uint? MaybeU32 { get; set; }
|
||||
public uint DefaultU32 { get; set; }
|
||||
public long JustI64 { get; set; }
|
||||
public long? MaybeI64 { get; set; }
|
||||
public long DefaultI64 { get; set; }
|
||||
public ulong JustU64 { get; set; }
|
||||
public ulong? MaybeU64 { get; set; }
|
||||
public ulong DefaultU64 { get; set; }
|
||||
public float JustF32 { get; set; }
|
||||
public float? MaybeF32 { get; set; }
|
||||
public float DefaultF32 { get; set; }
|
||||
public double JustF64 { get; set; }
|
||||
public double? MaybeF64 { get; set; }
|
||||
public double DefaultF64 { get; set; }
|
||||
public bool JustBool { get; set; }
|
||||
public bool? MaybeBool { get; set; }
|
||||
public bool DefaultBool { get; set; }
|
||||
public optional_scalars.OptionalByte JustEnum { get; set; }
|
||||
public optional_scalars.OptionalByte? MaybeEnum { get; set; }
|
||||
public optional_scalars.OptionalByte DefaultEnum { get; set; }
|
||||
|
||||
public ScalarStuffT() {
|
||||
this.JustI8 = 0;
|
||||
this.MaybeI8 = null;
|
||||
this.DefaultI8 = 42;
|
||||
this.JustU8 = 0;
|
||||
this.MaybeU8 = null;
|
||||
this.DefaultU8 = 42;
|
||||
this.JustI16 = 0;
|
||||
this.MaybeI16 = null;
|
||||
this.DefaultI16 = 42;
|
||||
this.JustU16 = 0;
|
||||
this.MaybeU16 = null;
|
||||
this.DefaultU16 = 42;
|
||||
this.JustI32 = 0;
|
||||
this.MaybeI32 = null;
|
||||
this.DefaultI32 = 42;
|
||||
this.JustU32 = 0;
|
||||
this.MaybeU32 = null;
|
||||
this.DefaultU32 = 42;
|
||||
this.JustI64 = 0;
|
||||
this.MaybeI64 = null;
|
||||
this.DefaultI64 = 42;
|
||||
this.JustU64 = 0;
|
||||
this.MaybeU64 = null;
|
||||
this.DefaultU64 = 42;
|
||||
this.JustF32 = 0.0f;
|
||||
this.MaybeF32 = null;
|
||||
this.DefaultF32 = 42.0f;
|
||||
this.JustF64 = 0.0;
|
||||
this.MaybeF64 = null;
|
||||
this.DefaultF64 = 42.0;
|
||||
this.JustBool = false;
|
||||
this.MaybeBool = null;
|
||||
this.DefaultBool = true;
|
||||
this.JustEnum = optional_scalars.OptionalByte.None;
|
||||
this.MaybeEnum = null;
|
||||
this.DefaultEnum = optional_scalars.OptionalByte.One;
|
||||
}
|
||||
public static ScalarStuffT DeserializeFromBinary(byte[] fbBuffer) {
|
||||
return ScalarStuff.GetRootAsScalarStuff(new ByteBuffer(fbBuffer)).UnPack();
|
||||
}
|
||||
public byte[] SerializeToBinary() {
|
||||
var fbb = new FlatBufferBuilder(0x10000);
|
||||
ScalarStuff.FinishScalarStuffBuffer(fbb, ScalarStuff.Pack(fbb, this));
|
||||
return fbb.DataBuffer.ToSizedArray();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static public class ScalarStuffVerify
|
||||
{
|
||||
static public bool Verify(Google.FlatBuffers.Verifier verifier, uint tablePos)
|
||||
{
|
||||
return verifier.VerifyTableStart(tablePos)
|
||||
&& verifier.VerifyField(tablePos, 4 /*JustI8*/, 1 /*sbyte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 6 /*MaybeI8*/, 1 /*sbyte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 8 /*DefaultI8*/, 1 /*sbyte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 10 /*JustU8*/, 1 /*byte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 12 /*MaybeU8*/, 1 /*byte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 14 /*DefaultU8*/, 1 /*byte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 16 /*JustI16*/, 2 /*short*/, 2, false)
|
||||
&& verifier.VerifyField(tablePos, 18 /*MaybeI16*/, 2 /*short*/, 2, false)
|
||||
&& verifier.VerifyField(tablePos, 20 /*DefaultI16*/, 2 /*short*/, 2, false)
|
||||
&& verifier.VerifyField(tablePos, 22 /*JustU16*/, 2 /*ushort*/, 2, false)
|
||||
&& verifier.VerifyField(tablePos, 24 /*MaybeU16*/, 2 /*ushort*/, 2, false)
|
||||
&& verifier.VerifyField(tablePos, 26 /*DefaultU16*/, 2 /*ushort*/, 2, false)
|
||||
&& verifier.VerifyField(tablePos, 28 /*JustI32*/, 4 /*int*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 30 /*MaybeI32*/, 4 /*int*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 32 /*DefaultI32*/, 4 /*int*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 34 /*JustU32*/, 4 /*uint*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 36 /*MaybeU32*/, 4 /*uint*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 38 /*DefaultU32*/, 4 /*uint*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 40 /*JustI64*/, 8 /*long*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 42 /*MaybeI64*/, 8 /*long*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 44 /*DefaultI64*/, 8 /*long*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 46 /*JustU64*/, 8 /*ulong*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 48 /*MaybeU64*/, 8 /*ulong*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 50 /*DefaultU64*/, 8 /*ulong*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 52 /*JustF32*/, 4 /*float*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 54 /*MaybeF32*/, 4 /*float*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 56 /*DefaultF32*/, 4 /*float*/, 4, false)
|
||||
&& verifier.VerifyField(tablePos, 58 /*JustF64*/, 8 /*double*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 60 /*MaybeF64*/, 8 /*double*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 62 /*DefaultF64*/, 8 /*double*/, 8, false)
|
||||
&& verifier.VerifyField(tablePos, 64 /*JustBool*/, 1 /*bool*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 66 /*MaybeBool*/, 1 /*bool*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 68 /*DefaultBool*/, 1 /*bool*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 70 /*JustEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 72 /*MaybeEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false)
|
||||
&& verifier.VerifyField(tablePos, 74 /*DefaultEnum*/, 1 /*optional_scalars.OptionalByte*/, 1, false)
|
||||
&& verifier.VerifyTableEnd(tablePos);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,756 @@
|
||||
// Code generated by the FlatBuffers compiler. DO NOT EDIT.
|
||||
|
||||
package optional_scalars
|
||||
|
||||
import (
|
||||
flatbuffers "github.com/google/flatbuffers/go"
|
||||
)
|
||||
|
||||
type ScalarStuffT struct {
|
||||
JustI8 int8 `json:"just_i8"`
|
||||
MaybeI8 *int8 `json:"maybe_i8"`
|
||||
DefaultI8 int8 `json:"default_i8"`
|
||||
JustU8 byte `json:"just_u8"`
|
||||
MaybeU8 *byte `json:"maybe_u8"`
|
||||
DefaultU8 byte `json:"default_u8"`
|
||||
JustI16 int16 `json:"just_i16"`
|
||||
MaybeI16 *int16 `json:"maybe_i16"`
|
||||
DefaultI16 int16 `json:"default_i16"`
|
||||
JustU16 uint16 `json:"just_u16"`
|
||||
MaybeU16 *uint16 `json:"maybe_u16"`
|
||||
DefaultU16 uint16 `json:"default_u16"`
|
||||
JustI32 int32 `json:"just_i32"`
|
||||
MaybeI32 *int32 `json:"maybe_i32"`
|
||||
DefaultI32 int32 `json:"default_i32"`
|
||||
JustU32 uint32 `json:"just_u32"`
|
||||
MaybeU32 *uint32 `json:"maybe_u32"`
|
||||
DefaultU32 uint32 `json:"default_u32"`
|
||||
JustI64 int64 `json:"just_i64"`
|
||||
MaybeI64 *int64 `json:"maybe_i64"`
|
||||
DefaultI64 int64 `json:"default_i64"`
|
||||
JustU64 uint64 `json:"just_u64"`
|
||||
MaybeU64 *uint64 `json:"maybe_u64"`
|
||||
DefaultU64 uint64 `json:"default_u64"`
|
||||
JustF32 float32 `json:"just_f32"`
|
||||
MaybeF32 *float32 `json:"maybe_f32"`
|
||||
DefaultF32 float32 `json:"default_f32"`
|
||||
JustF64 float64 `json:"just_f64"`
|
||||
MaybeF64 *float64 `json:"maybe_f64"`
|
||||
DefaultF64 float64 `json:"default_f64"`
|
||||
JustBool bool `json:"just_bool"`
|
||||
MaybeBool *bool `json:"maybe_bool"`
|
||||
DefaultBool bool `json:"default_bool"`
|
||||
JustEnum OptionalByte `json:"just_enum"`
|
||||
MaybeEnum *OptionalByte `json:"maybe_enum"`
|
||||
DefaultEnum OptionalByte `json:"default_enum"`
|
||||
}
|
||||
|
||||
func (t *ScalarStuffT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
if t == nil { return 0 }
|
||||
ScalarStuffStart(builder)
|
||||
ScalarStuffAddJustI8(builder, t.JustI8)
|
||||
if t.MaybeI8 != nil {
|
||||
ScalarStuffAddMaybeI8(builder, *t.MaybeI8)
|
||||
}
|
||||
ScalarStuffAddDefaultI8(builder, t.DefaultI8)
|
||||
ScalarStuffAddJustU8(builder, t.JustU8)
|
||||
if t.MaybeU8 != nil {
|
||||
ScalarStuffAddMaybeU8(builder, *t.MaybeU8)
|
||||
}
|
||||
ScalarStuffAddDefaultU8(builder, t.DefaultU8)
|
||||
ScalarStuffAddJustI16(builder, t.JustI16)
|
||||
if t.MaybeI16 != nil {
|
||||
ScalarStuffAddMaybeI16(builder, *t.MaybeI16)
|
||||
}
|
||||
ScalarStuffAddDefaultI16(builder, t.DefaultI16)
|
||||
ScalarStuffAddJustU16(builder, t.JustU16)
|
||||
if t.MaybeU16 != nil {
|
||||
ScalarStuffAddMaybeU16(builder, *t.MaybeU16)
|
||||
}
|
||||
ScalarStuffAddDefaultU16(builder, t.DefaultU16)
|
||||
ScalarStuffAddJustI32(builder, t.JustI32)
|
||||
if t.MaybeI32 != nil {
|
||||
ScalarStuffAddMaybeI32(builder, *t.MaybeI32)
|
||||
}
|
||||
ScalarStuffAddDefaultI32(builder, t.DefaultI32)
|
||||
ScalarStuffAddJustU32(builder, t.JustU32)
|
||||
if t.MaybeU32 != nil {
|
||||
ScalarStuffAddMaybeU32(builder, *t.MaybeU32)
|
||||
}
|
||||
ScalarStuffAddDefaultU32(builder, t.DefaultU32)
|
||||
ScalarStuffAddJustI64(builder, t.JustI64)
|
||||
if t.MaybeI64 != nil {
|
||||
ScalarStuffAddMaybeI64(builder, *t.MaybeI64)
|
||||
}
|
||||
ScalarStuffAddDefaultI64(builder, t.DefaultI64)
|
||||
ScalarStuffAddJustU64(builder, t.JustU64)
|
||||
if t.MaybeU64 != nil {
|
||||
ScalarStuffAddMaybeU64(builder, *t.MaybeU64)
|
||||
}
|
||||
ScalarStuffAddDefaultU64(builder, t.DefaultU64)
|
||||
ScalarStuffAddJustF32(builder, t.JustF32)
|
||||
if t.MaybeF32 != nil {
|
||||
ScalarStuffAddMaybeF32(builder, *t.MaybeF32)
|
||||
}
|
||||
ScalarStuffAddDefaultF32(builder, t.DefaultF32)
|
||||
ScalarStuffAddJustF64(builder, t.JustF64)
|
||||
if t.MaybeF64 != nil {
|
||||
ScalarStuffAddMaybeF64(builder, *t.MaybeF64)
|
||||
}
|
||||
ScalarStuffAddDefaultF64(builder, t.DefaultF64)
|
||||
ScalarStuffAddJustBool(builder, t.JustBool)
|
||||
if t.MaybeBool != nil {
|
||||
ScalarStuffAddMaybeBool(builder, *t.MaybeBool)
|
||||
}
|
||||
ScalarStuffAddDefaultBool(builder, t.DefaultBool)
|
||||
ScalarStuffAddJustEnum(builder, t.JustEnum)
|
||||
if t.MaybeEnum != nil {
|
||||
ScalarStuffAddMaybeEnum(builder, *t.MaybeEnum)
|
||||
}
|
||||
ScalarStuffAddDefaultEnum(builder, t.DefaultEnum)
|
||||
return ScalarStuffEnd(builder)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) UnPackTo(t *ScalarStuffT) {
|
||||
t.JustI8 = rcv.JustI8()
|
||||
t.MaybeI8 = rcv.MaybeI8()
|
||||
t.DefaultI8 = rcv.DefaultI8()
|
||||
t.JustU8 = rcv.JustU8()
|
||||
t.MaybeU8 = rcv.MaybeU8()
|
||||
t.DefaultU8 = rcv.DefaultU8()
|
||||
t.JustI16 = rcv.JustI16()
|
||||
t.MaybeI16 = rcv.MaybeI16()
|
||||
t.DefaultI16 = rcv.DefaultI16()
|
||||
t.JustU16 = rcv.JustU16()
|
||||
t.MaybeU16 = rcv.MaybeU16()
|
||||
t.DefaultU16 = rcv.DefaultU16()
|
||||
t.JustI32 = rcv.JustI32()
|
||||
t.MaybeI32 = rcv.MaybeI32()
|
||||
t.DefaultI32 = rcv.DefaultI32()
|
||||
t.JustU32 = rcv.JustU32()
|
||||
t.MaybeU32 = rcv.MaybeU32()
|
||||
t.DefaultU32 = rcv.DefaultU32()
|
||||
t.JustI64 = rcv.JustI64()
|
||||
t.MaybeI64 = rcv.MaybeI64()
|
||||
t.DefaultI64 = rcv.DefaultI64()
|
||||
t.JustU64 = rcv.JustU64()
|
||||
t.MaybeU64 = rcv.MaybeU64()
|
||||
t.DefaultU64 = rcv.DefaultU64()
|
||||
t.JustF32 = rcv.JustF32()
|
||||
t.MaybeF32 = rcv.MaybeF32()
|
||||
t.DefaultF32 = rcv.DefaultF32()
|
||||
t.JustF64 = rcv.JustF64()
|
||||
t.MaybeF64 = rcv.MaybeF64()
|
||||
t.DefaultF64 = rcv.DefaultF64()
|
||||
t.JustBool = rcv.JustBool()
|
||||
t.MaybeBool = rcv.MaybeBool()
|
||||
t.DefaultBool = rcv.DefaultBool()
|
||||
t.JustEnum = rcv.JustEnum()
|
||||
t.MaybeEnum = rcv.MaybeEnum()
|
||||
t.DefaultEnum = rcv.DefaultEnum()
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) UnPack() *ScalarStuffT {
|
||||
if rcv == nil { return nil }
|
||||
t := &ScalarStuffT{}
|
||||
rcv.UnPackTo(t)
|
||||
return t
|
||||
}
|
||||
|
||||
type ScalarStuff struct {
|
||||
_tab flatbuffers.Table
|
||||
}
|
||||
|
||||
func GetRootAsScalarStuff(buf []byte, offset flatbuffers.UOffsetT) *ScalarStuff {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset:])
|
||||
x := &ScalarStuff{}
|
||||
x.Init(buf, n+offset)
|
||||
return x
|
||||
}
|
||||
|
||||
func GetSizePrefixedRootAsScalarStuff(buf []byte, offset flatbuffers.UOffsetT) *ScalarStuff {
|
||||
n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
|
||||
x := &ScalarStuff{}
|
||||
x.Init(buf, n+offset+flatbuffers.SizeUint32)
|
||||
return x
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) Init(buf []byte, i flatbuffers.UOffsetT) {
|
||||
rcv._tab.Bytes = buf
|
||||
rcv._tab.Pos = i
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) Table() flatbuffers.Table {
|
||||
return rcv._tab
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustI8() int8 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt8(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustI8(n int8) bool {
|
||||
return rcv._tab.MutateInt8Slot(4, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeI8() *int8 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetInt8(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeI8(n int8) bool {
|
||||
return rcv._tab.MutateInt8Slot(6, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultI8() int8 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt8(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultI8(n int8) bool {
|
||||
return rcv._tab.MutateInt8Slot(8, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustU8() byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetByte(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustU8(n byte) bool {
|
||||
return rcv._tab.MutateByteSlot(10, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeU8() *byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetByte(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeU8(n byte) bool {
|
||||
return rcv._tab.MutateByteSlot(12, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultU8() byte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetByte(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultU8(n byte) bool {
|
||||
return rcv._tab.MutateByteSlot(14, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustI16() int16 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt16(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustI16(n int16) bool {
|
||||
return rcv._tab.MutateInt16Slot(16, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeI16() *int16 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetInt16(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeI16(n int16) bool {
|
||||
return rcv._tab.MutateInt16Slot(18, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultI16() int16 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt16(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultI16(n int16) bool {
|
||||
return rcv._tab.MutateInt16Slot(20, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustU16() uint16 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(22))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint16(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustU16(n uint16) bool {
|
||||
return rcv._tab.MutateUint16Slot(22, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeU16() *uint16 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(24))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetUint16(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeU16(n uint16) bool {
|
||||
return rcv._tab.MutateUint16Slot(24, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultU16() uint16 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(26))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint16(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultU16(n uint16) bool {
|
||||
return rcv._tab.MutateUint16Slot(26, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustI32() int32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(28))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustI32(n int32) bool {
|
||||
return rcv._tab.MutateInt32Slot(28, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeI32() *int32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(30))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetInt32(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeI32(n int32) bool {
|
||||
return rcv._tab.MutateInt32Slot(30, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultI32() int32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(32))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultI32(n int32) bool {
|
||||
return rcv._tab.MutateInt32Slot(32, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustU32() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(34))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustU32(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(34, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeU32() *uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(36))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeU32(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(36, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultU32() uint32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(38))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultU32(n uint32) bool {
|
||||
return rcv._tab.MutateUint32Slot(38, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustI64() int64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(40))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustI64(n int64) bool {
|
||||
return rcv._tab.MutateInt64Slot(40, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeI64() *int64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(42))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetInt64(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeI64(n int64) bool {
|
||||
return rcv._tab.MutateInt64Slot(42, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultI64() int64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(44))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetInt64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultI64(n int64) bool {
|
||||
return rcv._tab.MutateInt64Slot(44, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustU64() uint64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(46))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustU64(n uint64) bool {
|
||||
return rcv._tab.MutateUint64Slot(46, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeU64() *uint64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(48))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetUint64(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeU64(n uint64) bool {
|
||||
return rcv._tab.MutateUint64Slot(48, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultU64() uint64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(50))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetUint64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultU64(n uint64) bool {
|
||||
return rcv._tab.MutateUint64Slot(50, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustF32() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(52))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0.0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustF32(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(52, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeF32() *float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(54))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeF32(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(54, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultF32() float32 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(56))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat32(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42.0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultF32(n float32) bool {
|
||||
return rcv._tab.MutateFloat32Slot(56, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustF64() float64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(58))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 0.0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustF64(n float64) bool {
|
||||
return rcv._tab.MutateFloat64Slot(58, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeF64() *float64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(60))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetFloat64(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeF64(n float64) bool {
|
||||
return rcv._tab.MutateFloat64Slot(60, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultF64() float64 {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(62))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetFloat64(o + rcv._tab.Pos)
|
||||
}
|
||||
return 42.0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultF64(n float64) bool {
|
||||
return rcv._tab.MutateFloat64Slot(62, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustBool() bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(64))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetBool(o + rcv._tab.Pos)
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustBool(n bool) bool {
|
||||
return rcv._tab.MutateBoolSlot(64, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeBool() *bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(66))
|
||||
if o != 0 {
|
||||
v := rcv._tab.GetBool(o + rcv._tab.Pos)
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeBool(n bool) bool {
|
||||
return rcv._tab.MutateBoolSlot(66, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultBool() bool {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(68))
|
||||
if o != 0 {
|
||||
return rcv._tab.GetBool(o + rcv._tab.Pos)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultBool(n bool) bool {
|
||||
return rcv._tab.MutateBoolSlot(68, n)
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) JustEnum() OptionalByte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(70))
|
||||
if o != 0 {
|
||||
return OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
|
||||
}
|
||||
return 0
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateJustEnum(n OptionalByte) bool {
|
||||
return rcv._tab.MutateInt8Slot(70, int8(n))
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MaybeEnum() *OptionalByte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(72))
|
||||
if o != 0 {
|
||||
v := OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
|
||||
return &v
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateMaybeEnum(n OptionalByte) bool {
|
||||
return rcv._tab.MutateInt8Slot(72, int8(n))
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) DefaultEnum() OptionalByte {
|
||||
o := flatbuffers.UOffsetT(rcv._tab.Offset(74))
|
||||
if o != 0 {
|
||||
return OptionalByte(rcv._tab.GetInt8(o + rcv._tab.Pos))
|
||||
}
|
||||
return 1
|
||||
}
|
||||
|
||||
func (rcv *ScalarStuff) MutateDefaultEnum(n OptionalByte) bool {
|
||||
return rcv._tab.MutateInt8Slot(74, int8(n))
|
||||
}
|
||||
|
||||
func ScalarStuffStart(builder *flatbuffers.Builder) {
|
||||
builder.StartObject(36)
|
||||
}
|
||||
func ScalarStuffAddJustI8(builder *flatbuffers.Builder, justI8 int8) {
|
||||
builder.PrependInt8Slot(0, justI8, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeI8(builder *flatbuffers.Builder, maybeI8 int8) {
|
||||
builder.PrependInt8(maybeI8)
|
||||
builder.Slot(1)
|
||||
}
|
||||
func ScalarStuffAddDefaultI8(builder *flatbuffers.Builder, defaultI8 int8) {
|
||||
builder.PrependInt8Slot(2, defaultI8, 42)
|
||||
}
|
||||
func ScalarStuffAddJustU8(builder *flatbuffers.Builder, justU8 byte) {
|
||||
builder.PrependByteSlot(3, justU8, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeU8(builder *flatbuffers.Builder, maybeU8 byte) {
|
||||
builder.PrependByte(maybeU8)
|
||||
builder.Slot(4)
|
||||
}
|
||||
func ScalarStuffAddDefaultU8(builder *flatbuffers.Builder, defaultU8 byte) {
|
||||
builder.PrependByteSlot(5, defaultU8, 42)
|
||||
}
|
||||
func ScalarStuffAddJustI16(builder *flatbuffers.Builder, justI16 int16) {
|
||||
builder.PrependInt16Slot(6, justI16, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeI16(builder *flatbuffers.Builder, maybeI16 int16) {
|
||||
builder.PrependInt16(maybeI16)
|
||||
builder.Slot(7)
|
||||
}
|
||||
func ScalarStuffAddDefaultI16(builder *flatbuffers.Builder, defaultI16 int16) {
|
||||
builder.PrependInt16Slot(8, defaultI16, 42)
|
||||
}
|
||||
func ScalarStuffAddJustU16(builder *flatbuffers.Builder, justU16 uint16) {
|
||||
builder.PrependUint16Slot(9, justU16, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeU16(builder *flatbuffers.Builder, maybeU16 uint16) {
|
||||
builder.PrependUint16(maybeU16)
|
||||
builder.Slot(10)
|
||||
}
|
||||
func ScalarStuffAddDefaultU16(builder *flatbuffers.Builder, defaultU16 uint16) {
|
||||
builder.PrependUint16Slot(11, defaultU16, 42)
|
||||
}
|
||||
func ScalarStuffAddJustI32(builder *flatbuffers.Builder, justI32 int32) {
|
||||
builder.PrependInt32Slot(12, justI32, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeI32(builder *flatbuffers.Builder, maybeI32 int32) {
|
||||
builder.PrependInt32(maybeI32)
|
||||
builder.Slot(13)
|
||||
}
|
||||
func ScalarStuffAddDefaultI32(builder *flatbuffers.Builder, defaultI32 int32) {
|
||||
builder.PrependInt32Slot(14, defaultI32, 42)
|
||||
}
|
||||
func ScalarStuffAddJustU32(builder *flatbuffers.Builder, justU32 uint32) {
|
||||
builder.PrependUint32Slot(15, justU32, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeU32(builder *flatbuffers.Builder, maybeU32 uint32) {
|
||||
builder.PrependUint32(maybeU32)
|
||||
builder.Slot(16)
|
||||
}
|
||||
func ScalarStuffAddDefaultU32(builder *flatbuffers.Builder, defaultU32 uint32) {
|
||||
builder.PrependUint32Slot(17, defaultU32, 42)
|
||||
}
|
||||
func ScalarStuffAddJustI64(builder *flatbuffers.Builder, justI64 int64) {
|
||||
builder.PrependInt64Slot(18, justI64, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeI64(builder *flatbuffers.Builder, maybeI64 int64) {
|
||||
builder.PrependInt64(maybeI64)
|
||||
builder.Slot(19)
|
||||
}
|
||||
func ScalarStuffAddDefaultI64(builder *flatbuffers.Builder, defaultI64 int64) {
|
||||
builder.PrependInt64Slot(20, defaultI64, 42)
|
||||
}
|
||||
func ScalarStuffAddJustU64(builder *flatbuffers.Builder, justU64 uint64) {
|
||||
builder.PrependUint64Slot(21, justU64, 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeU64(builder *flatbuffers.Builder, maybeU64 uint64) {
|
||||
builder.PrependUint64(maybeU64)
|
||||
builder.Slot(22)
|
||||
}
|
||||
func ScalarStuffAddDefaultU64(builder *flatbuffers.Builder, defaultU64 uint64) {
|
||||
builder.PrependUint64Slot(23, defaultU64, 42)
|
||||
}
|
||||
func ScalarStuffAddJustF32(builder *flatbuffers.Builder, justF32 float32) {
|
||||
builder.PrependFloat32Slot(24, justF32, 0.0)
|
||||
}
|
||||
func ScalarStuffAddMaybeF32(builder *flatbuffers.Builder, maybeF32 float32) {
|
||||
builder.PrependFloat32(maybeF32)
|
||||
builder.Slot(25)
|
||||
}
|
||||
func ScalarStuffAddDefaultF32(builder *flatbuffers.Builder, defaultF32 float32) {
|
||||
builder.PrependFloat32Slot(26, defaultF32, 42.0)
|
||||
}
|
||||
func ScalarStuffAddJustF64(builder *flatbuffers.Builder, justF64 float64) {
|
||||
builder.PrependFloat64Slot(27, justF64, 0.0)
|
||||
}
|
||||
func ScalarStuffAddMaybeF64(builder *flatbuffers.Builder, maybeF64 float64) {
|
||||
builder.PrependFloat64(maybeF64)
|
||||
builder.Slot(28)
|
||||
}
|
||||
func ScalarStuffAddDefaultF64(builder *flatbuffers.Builder, defaultF64 float64) {
|
||||
builder.PrependFloat64Slot(29, defaultF64, 42.0)
|
||||
}
|
||||
func ScalarStuffAddJustBool(builder *flatbuffers.Builder, justBool bool) {
|
||||
builder.PrependBoolSlot(30, justBool, false)
|
||||
}
|
||||
func ScalarStuffAddMaybeBool(builder *flatbuffers.Builder, maybeBool bool) {
|
||||
builder.PrependBool(maybeBool)
|
||||
builder.Slot(31)
|
||||
}
|
||||
func ScalarStuffAddDefaultBool(builder *flatbuffers.Builder, defaultBool bool) {
|
||||
builder.PrependBoolSlot(32, defaultBool, true)
|
||||
}
|
||||
func ScalarStuffAddJustEnum(builder *flatbuffers.Builder, justEnum OptionalByte) {
|
||||
builder.PrependInt8Slot(33, int8(justEnum), 0)
|
||||
}
|
||||
func ScalarStuffAddMaybeEnum(builder *flatbuffers.Builder, maybeEnum OptionalByte) {
|
||||
builder.PrependInt8(int8(maybeEnum))
|
||||
builder.Slot(34)
|
||||
}
|
||||
func ScalarStuffAddDefaultEnum(builder *flatbuffers.Builder, defaultEnum OptionalByte) {
|
||||
builder.PrependInt8Slot(35, int8(defaultEnum), 1)
|
||||
}
|
||||
func ScalarStuffEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
|
||||
return builder.EndObject()
|
||||
}
|
||||
@@ -0,0 +1,208 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
package optional_scalars;
|
||||
|
||||
import com.google.flatbuffers.BaseVector;
|
||||
import com.google.flatbuffers.BooleanVector;
|
||||
import com.google.flatbuffers.ByteVector;
|
||||
import com.google.flatbuffers.Constants;
|
||||
import com.google.flatbuffers.DoubleVector;
|
||||
import com.google.flatbuffers.FlatBufferBuilder;
|
||||
import com.google.flatbuffers.FloatVector;
|
||||
import com.google.flatbuffers.IntVector;
|
||||
import com.google.flatbuffers.LongVector;
|
||||
import com.google.flatbuffers.ShortVector;
|
||||
import com.google.flatbuffers.StringVector;
|
||||
import com.google.flatbuffers.Struct;
|
||||
import com.google.flatbuffers.Table;
|
||||
import com.google.flatbuffers.UnionVector;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.nio.ByteOrder;
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
public final class ScalarStuff extends Table {
|
||||
public static void ValidateVersion() { Constants.FLATBUFFERS_24_3_25(); }
|
||||
public static ScalarStuff getRootAsScalarStuff(ByteBuffer _bb) { return getRootAsScalarStuff(_bb, new ScalarStuff()); }
|
||||
public static ScalarStuff getRootAsScalarStuff(ByteBuffer _bb, ScalarStuff obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
|
||||
public static boolean ScalarStuffBufferHasIdentifier(ByteBuffer _bb) { return __has_identifier(_bb, "NULL"); }
|
||||
public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
|
||||
public ScalarStuff __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
|
||||
|
||||
public byte justI8() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeI8() { return 0 != __offset(6); }
|
||||
public byte maybeI8() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public byte defaultI8() { int o = __offset(8); return o != 0 ? bb.get(o + bb_pos) : 42; }
|
||||
public int justU8() { int o = __offset(10); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
|
||||
public boolean hasMaybeU8() { return 0 != __offset(12); }
|
||||
public int maybeU8() { int o = __offset(12); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; }
|
||||
public int defaultU8() { int o = __offset(14); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 42; }
|
||||
public short justI16() { int o = __offset(16); return o != 0 ? bb.getShort(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeI16() { return 0 != __offset(18); }
|
||||
public short maybeI16() { int o = __offset(18); return o != 0 ? bb.getShort(o + bb_pos) : 0; }
|
||||
public short defaultI16() { int o = __offset(20); return o != 0 ? bb.getShort(o + bb_pos) : 42; }
|
||||
public int justU16() { int o = __offset(22); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
|
||||
public boolean hasMaybeU16() { return 0 != __offset(24); }
|
||||
public int maybeU16() { int o = __offset(24); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
|
||||
public int defaultU16() { int o = __offset(26); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 42; }
|
||||
public int justI32() { int o = __offset(28); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeI32() { return 0 != __offset(30); }
|
||||
public int maybeI32() { int o = __offset(30); return o != 0 ? bb.getInt(o + bb_pos) : 0; }
|
||||
public int defaultI32() { int o = __offset(32); return o != 0 ? bb.getInt(o + bb_pos) : 42; }
|
||||
public long justU32() { int o = __offset(34); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
|
||||
public boolean hasMaybeU32() { return 0 != __offset(36); }
|
||||
public long maybeU32() { int o = __offset(36); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
|
||||
public long defaultU32() { int o = __offset(38); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 42L; }
|
||||
public long justI64() { int o = __offset(40); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public boolean hasMaybeI64() { return 0 != __offset(42); }
|
||||
public long maybeI64() { int o = __offset(42); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public long defaultI64() { int o = __offset(44); return o != 0 ? bb.getLong(o + bb_pos) : 42L; }
|
||||
public long justU64() { int o = __offset(46); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public boolean hasMaybeU64() { return 0 != __offset(48); }
|
||||
public long maybeU64() { int o = __offset(48); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
|
||||
public long defaultU64() { int o = __offset(50); return o != 0 ? bb.getLong(o + bb_pos) : 42L; }
|
||||
public float justF32() { int o = __offset(52); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
|
||||
public boolean hasMaybeF32() { return 0 != __offset(54); }
|
||||
public float maybeF32() { int o = __offset(54); return o != 0 ? bb.getFloat(o + bb_pos) : 0f; }
|
||||
public float defaultF32() { int o = __offset(56); return o != 0 ? bb.getFloat(o + bb_pos) : 42.0f; }
|
||||
public double justF64() { int o = __offset(58); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; }
|
||||
public boolean hasMaybeF64() { return 0 != __offset(60); }
|
||||
public double maybeF64() { int o = __offset(60); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; }
|
||||
public double defaultF64() { int o = __offset(62); return o != 0 ? bb.getDouble(o + bb_pos) : 42.0; }
|
||||
public boolean justBool() { int o = __offset(64); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
|
||||
public boolean hasMaybeBool() { return 0 != __offset(66); }
|
||||
public boolean maybeBool() { int o = __offset(66); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
|
||||
public boolean defaultBool() { int o = __offset(68); return o != 0 ? 0!=bb.get(o + bb_pos) : true; }
|
||||
public byte justEnum() { int o = __offset(70); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public boolean hasMaybeEnum() { return 0 != __offset(72); }
|
||||
public byte maybeEnum() { int o = __offset(72); return o != 0 ? bb.get(o + bb_pos) : 0; }
|
||||
public byte defaultEnum() { int o = __offset(74); return o != 0 ? bb.get(o + bb_pos) : 1; }
|
||||
|
||||
public static int createScalarStuff(FlatBufferBuilder builder,
|
||||
byte justI8,
|
||||
byte maybeI8,
|
||||
byte defaultI8,
|
||||
int justU8,
|
||||
int maybeU8,
|
||||
int defaultU8,
|
||||
short justI16,
|
||||
short maybeI16,
|
||||
short defaultI16,
|
||||
int justU16,
|
||||
int maybeU16,
|
||||
int defaultU16,
|
||||
int justI32,
|
||||
int maybeI32,
|
||||
int defaultI32,
|
||||
long justU32,
|
||||
long maybeU32,
|
||||
long defaultU32,
|
||||
long justI64,
|
||||
long maybeI64,
|
||||
long defaultI64,
|
||||
long justU64,
|
||||
long maybeU64,
|
||||
long defaultU64,
|
||||
float justF32,
|
||||
float maybeF32,
|
||||
float defaultF32,
|
||||
double justF64,
|
||||
double maybeF64,
|
||||
double defaultF64,
|
||||
boolean justBool,
|
||||
boolean maybeBool,
|
||||
boolean defaultBool,
|
||||
byte justEnum,
|
||||
byte maybeEnum,
|
||||
byte defaultEnum) {
|
||||
builder.startTable(36);
|
||||
ScalarStuff.addDefaultF64(builder, defaultF64);
|
||||
ScalarStuff.addMaybeF64(builder, maybeF64);
|
||||
ScalarStuff.addJustF64(builder, justF64);
|
||||
ScalarStuff.addDefaultU64(builder, defaultU64);
|
||||
ScalarStuff.addMaybeU64(builder, maybeU64);
|
||||
ScalarStuff.addJustU64(builder, justU64);
|
||||
ScalarStuff.addDefaultI64(builder, defaultI64);
|
||||
ScalarStuff.addMaybeI64(builder, maybeI64);
|
||||
ScalarStuff.addJustI64(builder, justI64);
|
||||
ScalarStuff.addDefaultF32(builder, defaultF32);
|
||||
ScalarStuff.addMaybeF32(builder, maybeF32);
|
||||
ScalarStuff.addJustF32(builder, justF32);
|
||||
ScalarStuff.addDefaultU32(builder, defaultU32);
|
||||
ScalarStuff.addMaybeU32(builder, maybeU32);
|
||||
ScalarStuff.addJustU32(builder, justU32);
|
||||
ScalarStuff.addDefaultI32(builder, defaultI32);
|
||||
ScalarStuff.addMaybeI32(builder, maybeI32);
|
||||
ScalarStuff.addJustI32(builder, justI32);
|
||||
ScalarStuff.addDefaultU16(builder, defaultU16);
|
||||
ScalarStuff.addMaybeU16(builder, maybeU16);
|
||||
ScalarStuff.addJustU16(builder, justU16);
|
||||
ScalarStuff.addDefaultI16(builder, defaultI16);
|
||||
ScalarStuff.addMaybeI16(builder, maybeI16);
|
||||
ScalarStuff.addJustI16(builder, justI16);
|
||||
ScalarStuff.addDefaultEnum(builder, defaultEnum);
|
||||
ScalarStuff.addMaybeEnum(builder, maybeEnum);
|
||||
ScalarStuff.addJustEnum(builder, justEnum);
|
||||
ScalarStuff.addDefaultBool(builder, defaultBool);
|
||||
ScalarStuff.addMaybeBool(builder, maybeBool);
|
||||
ScalarStuff.addJustBool(builder, justBool);
|
||||
ScalarStuff.addDefaultU8(builder, defaultU8);
|
||||
ScalarStuff.addMaybeU8(builder, maybeU8);
|
||||
ScalarStuff.addJustU8(builder, justU8);
|
||||
ScalarStuff.addDefaultI8(builder, defaultI8);
|
||||
ScalarStuff.addMaybeI8(builder, maybeI8);
|
||||
ScalarStuff.addJustI8(builder, justI8);
|
||||
return ScalarStuff.endScalarStuff(builder);
|
||||
}
|
||||
|
||||
public static void startScalarStuff(FlatBufferBuilder builder) { builder.startTable(36); }
|
||||
public static void addJustI8(FlatBufferBuilder builder, byte justI8) { builder.addByte(0, justI8, 0); }
|
||||
public static void addMaybeI8(FlatBufferBuilder builder, byte maybeI8) { builder.addByte(1, maybeI8, 0); }
|
||||
public static void addDefaultI8(FlatBufferBuilder builder, byte defaultI8) { builder.addByte(2, defaultI8, 42); }
|
||||
public static void addJustU8(FlatBufferBuilder builder, int justU8) { builder.addByte(3, (byte) justU8, (byte) 0); }
|
||||
public static void addMaybeU8(FlatBufferBuilder builder, int maybeU8) { builder.addByte(4, (byte) maybeU8, (byte) 0); }
|
||||
public static void addDefaultU8(FlatBufferBuilder builder, int defaultU8) { builder.addByte(5, (byte) defaultU8, (byte) 42); }
|
||||
public static void addJustI16(FlatBufferBuilder builder, short justI16) { builder.addShort(6, justI16, 0); }
|
||||
public static void addMaybeI16(FlatBufferBuilder builder, short maybeI16) { builder.addShort(7, maybeI16, 0); }
|
||||
public static void addDefaultI16(FlatBufferBuilder builder, short defaultI16) { builder.addShort(8, defaultI16, 42); }
|
||||
public static void addJustU16(FlatBufferBuilder builder, int justU16) { builder.addShort(9, (short) justU16, (short) 0); }
|
||||
public static void addMaybeU16(FlatBufferBuilder builder, int maybeU16) { builder.addShort(10, (short) maybeU16, (short) 0); }
|
||||
public static void addDefaultU16(FlatBufferBuilder builder, int defaultU16) { builder.addShort(11, (short) defaultU16, (short) 42); }
|
||||
public static void addJustI32(FlatBufferBuilder builder, int justI32) { builder.addInt(12, justI32, 0); }
|
||||
public static void addMaybeI32(FlatBufferBuilder builder, int maybeI32) { builder.addInt(13, maybeI32, 0); }
|
||||
public static void addDefaultI32(FlatBufferBuilder builder, int defaultI32) { builder.addInt(14, defaultI32, 42); }
|
||||
public static void addJustU32(FlatBufferBuilder builder, long justU32) { builder.addInt(15, (int) justU32, (int) 0L); }
|
||||
public static void addMaybeU32(FlatBufferBuilder builder, long maybeU32) { builder.addInt(16, (int) maybeU32, (int) 0L); }
|
||||
public static void addDefaultU32(FlatBufferBuilder builder, long defaultU32) { builder.addInt(17, (int) defaultU32, (int) 42L); }
|
||||
public static void addJustI64(FlatBufferBuilder builder, long justI64) { builder.addLong(18, justI64, 0L); }
|
||||
public static void addMaybeI64(FlatBufferBuilder builder, long maybeI64) { builder.addLong(19, maybeI64, 0L); }
|
||||
public static void addDefaultI64(FlatBufferBuilder builder, long defaultI64) { builder.addLong(20, defaultI64, 42L); }
|
||||
public static void addJustU64(FlatBufferBuilder builder, long justU64) { builder.addLong(21, justU64, 0L); }
|
||||
public static void addMaybeU64(FlatBufferBuilder builder, long maybeU64) { builder.addLong(22, maybeU64, 0L); }
|
||||
public static void addDefaultU64(FlatBufferBuilder builder, long defaultU64) { builder.addLong(23, defaultU64, 42L); }
|
||||
public static void addJustF32(FlatBufferBuilder builder, float justF32) { builder.addFloat(24, justF32, 0.0f); }
|
||||
public static void addMaybeF32(FlatBufferBuilder builder, float maybeF32) { builder.addFloat(25, maybeF32, 0f); }
|
||||
public static void addDefaultF32(FlatBufferBuilder builder, float defaultF32) { builder.addFloat(26, defaultF32, 42.0f); }
|
||||
public static void addJustF64(FlatBufferBuilder builder, double justF64) { builder.addDouble(27, justF64, 0.0); }
|
||||
public static void addMaybeF64(FlatBufferBuilder builder, double maybeF64) { builder.addDouble(28, maybeF64, 0.0); }
|
||||
public static void addDefaultF64(FlatBufferBuilder builder, double defaultF64) { builder.addDouble(29, defaultF64, 42.0); }
|
||||
public static void addJustBool(FlatBufferBuilder builder, boolean justBool) { builder.addBoolean(30, justBool, false); }
|
||||
public static void addMaybeBool(FlatBufferBuilder builder, boolean maybeBool) { builder.addBoolean(31, maybeBool, false); }
|
||||
public static void addDefaultBool(FlatBufferBuilder builder, boolean defaultBool) { builder.addBoolean(32, defaultBool, true); }
|
||||
public static void addJustEnum(FlatBufferBuilder builder, byte justEnum) { builder.addByte(33, justEnum, 0); }
|
||||
public static void addMaybeEnum(FlatBufferBuilder builder, byte maybeEnum) { builder.addByte(34, maybeEnum, 0); }
|
||||
public static void addDefaultEnum(FlatBufferBuilder builder, byte defaultEnum) { builder.addByte(35, defaultEnum, 1); }
|
||||
public static int endScalarStuff(FlatBufferBuilder builder) {
|
||||
int o = builder.endTable();
|
||||
return o;
|
||||
}
|
||||
public static void finishScalarStuffBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset, "NULL"); }
|
||||
public static void finishSizePrefixedScalarStuffBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset, "NULL"); }
|
||||
|
||||
public static final class Vector extends BaseVector {
|
||||
public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
|
||||
|
||||
public ScalarStuff get(int j) { return get(new ScalarStuff(), j); }
|
||||
public ScalarStuff get(ScalarStuff obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,303 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
package optional_scalars
|
||||
|
||||
import com.google.flatbuffers.BaseVector
|
||||
import com.google.flatbuffers.BooleanVector
|
||||
import com.google.flatbuffers.ByteVector
|
||||
import com.google.flatbuffers.Constants
|
||||
import com.google.flatbuffers.DoubleVector
|
||||
import com.google.flatbuffers.FlatBufferBuilder
|
||||
import com.google.flatbuffers.FloatVector
|
||||
import com.google.flatbuffers.LongVector
|
||||
import com.google.flatbuffers.StringVector
|
||||
import com.google.flatbuffers.Struct
|
||||
import com.google.flatbuffers.Table
|
||||
import com.google.flatbuffers.UnionVector
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import kotlin.math.sign
|
||||
|
||||
@Suppress("unused")
|
||||
class ScalarStuff : Table() {
|
||||
|
||||
fun __init(_i: Int, _bb: ByteBuffer) {
|
||||
__reset(_i, _bb)
|
||||
}
|
||||
fun __assign(_i: Int, _bb: ByteBuffer) : ScalarStuff {
|
||||
__init(_i, _bb)
|
||||
return this
|
||||
}
|
||||
val justI8 : Byte
|
||||
get() {
|
||||
val o = __offset(4)
|
||||
return if(o != 0) bb.get(o + bb_pos) else 0
|
||||
}
|
||||
val maybeI8 : Byte?
|
||||
get() {
|
||||
val o = __offset(6)
|
||||
return if(o != 0) bb.get(o + bb_pos) else null
|
||||
}
|
||||
val defaultI8 : Byte
|
||||
get() {
|
||||
val o = __offset(8)
|
||||
return if(o != 0) bb.get(o + bb_pos) else 42
|
||||
}
|
||||
val justU8 : UByte
|
||||
get() {
|
||||
val o = __offset(10)
|
||||
return if(o != 0) bb.get(o + bb_pos).toUByte() else 0u
|
||||
}
|
||||
val maybeU8 : UByte?
|
||||
get() {
|
||||
val o = __offset(12)
|
||||
return if(o != 0) bb.get(o + bb_pos).toUByte() else null
|
||||
}
|
||||
val defaultU8 : UByte
|
||||
get() {
|
||||
val o = __offset(14)
|
||||
return if(o != 0) bb.get(o + bb_pos).toUByte() else 42u
|
||||
}
|
||||
val justI16 : Short
|
||||
get() {
|
||||
val o = __offset(16)
|
||||
return if(o != 0) bb.getShort(o + bb_pos) else 0
|
||||
}
|
||||
val maybeI16 : Short?
|
||||
get() {
|
||||
val o = __offset(18)
|
||||
return if(o != 0) bb.getShort(o + bb_pos) else null
|
||||
}
|
||||
val defaultI16 : Short
|
||||
get() {
|
||||
val o = __offset(20)
|
||||
return if(o != 0) bb.getShort(o + bb_pos) else 42
|
||||
}
|
||||
val justU16 : UShort
|
||||
get() {
|
||||
val o = __offset(22)
|
||||
return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 0u
|
||||
}
|
||||
val maybeU16 : UShort?
|
||||
get() {
|
||||
val o = __offset(24)
|
||||
return if(o != 0) bb.getShort(o + bb_pos).toUShort() else null
|
||||
}
|
||||
val defaultU16 : UShort
|
||||
get() {
|
||||
val o = __offset(26)
|
||||
return if(o != 0) bb.getShort(o + bb_pos).toUShort() else 42u
|
||||
}
|
||||
val justI32 : Int
|
||||
get() {
|
||||
val o = __offset(28)
|
||||
return if(o != 0) bb.getInt(o + bb_pos) else 0
|
||||
}
|
||||
val maybeI32 : Int?
|
||||
get() {
|
||||
val o = __offset(30)
|
||||
return if(o != 0) bb.getInt(o + bb_pos) else null
|
||||
}
|
||||
val defaultI32 : Int
|
||||
get() {
|
||||
val o = __offset(32)
|
||||
return if(o != 0) bb.getInt(o + bb_pos) else 42
|
||||
}
|
||||
val justU32 : UInt
|
||||
get() {
|
||||
val o = __offset(34)
|
||||
return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 0u
|
||||
}
|
||||
val maybeU32 : UInt?
|
||||
get() {
|
||||
val o = __offset(36)
|
||||
return if(o != 0) bb.getInt(o + bb_pos).toUInt() else null
|
||||
}
|
||||
val defaultU32 : UInt
|
||||
get() {
|
||||
val o = __offset(38)
|
||||
return if(o != 0) bb.getInt(o + bb_pos).toUInt() else 42u
|
||||
}
|
||||
val justI64 : Long
|
||||
get() {
|
||||
val o = __offset(40)
|
||||
return if(o != 0) bb.getLong(o + bb_pos) else 0L
|
||||
}
|
||||
val maybeI64 : Long?
|
||||
get() {
|
||||
val o = __offset(42)
|
||||
return if(o != 0) bb.getLong(o + bb_pos) else null
|
||||
}
|
||||
val defaultI64 : Long
|
||||
get() {
|
||||
val o = __offset(44)
|
||||
return if(o != 0) bb.getLong(o + bb_pos) else 42L
|
||||
}
|
||||
val justU64 : ULong
|
||||
get() {
|
||||
val o = __offset(46)
|
||||
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 0UL
|
||||
}
|
||||
val maybeU64 : ULong?
|
||||
get() {
|
||||
val o = __offset(48)
|
||||
return if(o != 0) bb.getLong(o + bb_pos).toULong() else null
|
||||
}
|
||||
val defaultU64 : ULong
|
||||
get() {
|
||||
val o = __offset(50)
|
||||
return if(o != 0) bb.getLong(o + bb_pos).toULong() else 42UL
|
||||
}
|
||||
val justF32 : Float
|
||||
get() {
|
||||
val o = __offset(52)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else 0.0f
|
||||
}
|
||||
val maybeF32 : Float?
|
||||
get() {
|
||||
val o = __offset(54)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else null
|
||||
}
|
||||
val defaultF32 : Float
|
||||
get() {
|
||||
val o = __offset(56)
|
||||
return if(o != 0) bb.getFloat(o + bb_pos) else 42.0f
|
||||
}
|
||||
val justF64 : Double
|
||||
get() {
|
||||
val o = __offset(58)
|
||||
return if(o != 0) bb.getDouble(o + bb_pos) else 0.0
|
||||
}
|
||||
val maybeF64 : Double?
|
||||
get() {
|
||||
val o = __offset(60)
|
||||
return if(o != 0) bb.getDouble(o + bb_pos) else null
|
||||
}
|
||||
val defaultF64 : Double
|
||||
get() {
|
||||
val o = __offset(62)
|
||||
return if(o != 0) bb.getDouble(o + bb_pos) else 42.0
|
||||
}
|
||||
val justBool : Boolean
|
||||
get() {
|
||||
val o = __offset(64)
|
||||
return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else false
|
||||
}
|
||||
val maybeBool : Boolean?
|
||||
get() {
|
||||
val o = __offset(66)
|
||||
return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else null
|
||||
}
|
||||
val defaultBool : Boolean
|
||||
get() {
|
||||
val o = __offset(68)
|
||||
return if(o != 0) 0.toByte() != bb.get(o + bb_pos) else true
|
||||
}
|
||||
val justEnum : Byte
|
||||
get() {
|
||||
val o = __offset(70)
|
||||
return if(o != 0) bb.get(o + bb_pos) else 0
|
||||
}
|
||||
val maybeEnum : Byte?
|
||||
get() {
|
||||
val o = __offset(72)
|
||||
return if(o != 0) bb.get(o + bb_pos) else null
|
||||
}
|
||||
val defaultEnum : Byte
|
||||
get() {
|
||||
val o = __offset(74)
|
||||
return if(o != 0) bb.get(o + bb_pos) else 1
|
||||
}
|
||||
companion object {
|
||||
fun validateVersion() = Constants.FLATBUFFERS_24_3_25()
|
||||
fun getRootAsScalarStuff(_bb: ByteBuffer): ScalarStuff = getRootAsScalarStuff(_bb, ScalarStuff())
|
||||
fun getRootAsScalarStuff(_bb: ByteBuffer, obj: ScalarStuff): ScalarStuff {
|
||||
_bb.order(ByteOrder.LITTLE_ENDIAN)
|
||||
return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
|
||||
}
|
||||
fun ScalarStuffBufferHasIdentifier(_bb: ByteBuffer) : Boolean = __has_identifier(_bb, "NULL")
|
||||
fun createScalarStuff(builder: FlatBufferBuilder, justI8: Byte, maybeI8: Byte?, defaultI8: Byte, justU8: UByte, maybeU8: UByte?, defaultU8: UByte, justI16: Short, maybeI16: Short?, defaultI16: Short, justU16: UShort, maybeU16: UShort?, defaultU16: UShort, justI32: Int, maybeI32: Int?, defaultI32: Int, justU32: UInt, maybeU32: UInt?, defaultU32: UInt, justI64: Long, maybeI64: Long?, defaultI64: Long, justU64: ULong, maybeU64: ULong?, defaultU64: ULong, justF32: Float, maybeF32: Float?, defaultF32: Float, justF64: Double, maybeF64: Double?, defaultF64: Double, justBool: Boolean, maybeBool: Boolean?, defaultBool: Boolean, justEnum: Byte, maybeEnum: Byte?, defaultEnum: Byte) : Int {
|
||||
builder.startTable(36)
|
||||
addDefaultF64(builder, defaultF64)
|
||||
maybeF64?.run { addMaybeF64(builder, maybeF64) }
|
||||
addJustF64(builder, justF64)
|
||||
addDefaultU64(builder, defaultU64)
|
||||
maybeU64?.run { addMaybeU64(builder, maybeU64) }
|
||||
addJustU64(builder, justU64)
|
||||
addDefaultI64(builder, defaultI64)
|
||||
maybeI64?.run { addMaybeI64(builder, maybeI64) }
|
||||
addJustI64(builder, justI64)
|
||||
addDefaultF32(builder, defaultF32)
|
||||
maybeF32?.run { addMaybeF32(builder, maybeF32) }
|
||||
addJustF32(builder, justF32)
|
||||
addDefaultU32(builder, defaultU32)
|
||||
maybeU32?.run { addMaybeU32(builder, maybeU32) }
|
||||
addJustU32(builder, justU32)
|
||||
addDefaultI32(builder, defaultI32)
|
||||
maybeI32?.run { addMaybeI32(builder, maybeI32) }
|
||||
addJustI32(builder, justI32)
|
||||
addDefaultU16(builder, defaultU16)
|
||||
maybeU16?.run { addMaybeU16(builder, maybeU16) }
|
||||
addJustU16(builder, justU16)
|
||||
addDefaultI16(builder, defaultI16)
|
||||
maybeI16?.run { addMaybeI16(builder, maybeI16) }
|
||||
addJustI16(builder, justI16)
|
||||
addDefaultEnum(builder, defaultEnum)
|
||||
maybeEnum?.run { addMaybeEnum(builder, maybeEnum) }
|
||||
addJustEnum(builder, justEnum)
|
||||
addDefaultBool(builder, defaultBool)
|
||||
maybeBool?.run { addMaybeBool(builder, maybeBool) }
|
||||
addJustBool(builder, justBool)
|
||||
addDefaultU8(builder, defaultU8)
|
||||
maybeU8?.run { addMaybeU8(builder, maybeU8) }
|
||||
addJustU8(builder, justU8)
|
||||
addDefaultI8(builder, defaultI8)
|
||||
maybeI8?.run { addMaybeI8(builder, maybeI8) }
|
||||
addJustI8(builder, justI8)
|
||||
return endScalarStuff(builder)
|
||||
}
|
||||
fun startScalarStuff(builder: FlatBufferBuilder) = builder.startTable(36)
|
||||
fun addJustI8(builder: FlatBufferBuilder, justI8: Byte) = builder.addByte(0, justI8, 0)
|
||||
fun addMaybeI8(builder: FlatBufferBuilder, maybeI8: Byte) = builder.addByte(1, maybeI8, 0)
|
||||
fun addDefaultI8(builder: FlatBufferBuilder, defaultI8: Byte) = builder.addByte(2, defaultI8, 42)
|
||||
fun addJustU8(builder: FlatBufferBuilder, justU8: UByte) = builder.addByte(3, justU8.toByte(), 0)
|
||||
fun addMaybeU8(builder: FlatBufferBuilder, maybeU8: UByte) = builder.addByte(4, maybeU8.toByte(), 0)
|
||||
fun addDefaultU8(builder: FlatBufferBuilder, defaultU8: UByte) = builder.addByte(5, defaultU8.toByte(), 42)
|
||||
fun addJustI16(builder: FlatBufferBuilder, justI16: Short) = builder.addShort(6, justI16, 0)
|
||||
fun addMaybeI16(builder: FlatBufferBuilder, maybeI16: Short) = builder.addShort(7, maybeI16, 0)
|
||||
fun addDefaultI16(builder: FlatBufferBuilder, defaultI16: Short) = builder.addShort(8, defaultI16, 42)
|
||||
fun addJustU16(builder: FlatBufferBuilder, justU16: UShort) = builder.addShort(9, justU16.toShort(), 0)
|
||||
fun addMaybeU16(builder: FlatBufferBuilder, maybeU16: UShort) = builder.addShort(10, maybeU16.toShort(), 0)
|
||||
fun addDefaultU16(builder: FlatBufferBuilder, defaultU16: UShort) = builder.addShort(11, defaultU16.toShort(), 42)
|
||||
fun addJustI32(builder: FlatBufferBuilder, justI32: Int) = builder.addInt(12, justI32, 0)
|
||||
fun addMaybeI32(builder: FlatBufferBuilder, maybeI32: Int) = builder.addInt(13, maybeI32, 0)
|
||||
fun addDefaultI32(builder: FlatBufferBuilder, defaultI32: Int) = builder.addInt(14, defaultI32, 42)
|
||||
fun addJustU32(builder: FlatBufferBuilder, justU32: UInt) = builder.addInt(15, justU32.toInt(), 0)
|
||||
fun addMaybeU32(builder: FlatBufferBuilder, maybeU32: UInt) = builder.addInt(16, maybeU32.toInt(), 0)
|
||||
fun addDefaultU32(builder: FlatBufferBuilder, defaultU32: UInt) = builder.addInt(17, defaultU32.toInt(), 42)
|
||||
fun addJustI64(builder: FlatBufferBuilder, justI64: Long) = builder.addLong(18, justI64, 0L)
|
||||
fun addMaybeI64(builder: FlatBufferBuilder, maybeI64: Long) = builder.addLong(19, maybeI64, 0)
|
||||
fun addDefaultI64(builder: FlatBufferBuilder, defaultI64: Long) = builder.addLong(20, defaultI64, 42L)
|
||||
fun addJustU64(builder: FlatBufferBuilder, justU64: ULong) = builder.addLong(21, justU64.toLong(), 0)
|
||||
fun addMaybeU64(builder: FlatBufferBuilder, maybeU64: ULong) = builder.addLong(22, maybeU64.toLong(), 0)
|
||||
fun addDefaultU64(builder: FlatBufferBuilder, defaultU64: ULong) = builder.addLong(23, defaultU64.toLong(), 42)
|
||||
fun addJustF32(builder: FlatBufferBuilder, justF32: Float) = builder.addFloat(24, justF32, 0.0)
|
||||
fun addMaybeF32(builder: FlatBufferBuilder, maybeF32: Float) = builder.addFloat(25, maybeF32, 0.0)
|
||||
fun addDefaultF32(builder: FlatBufferBuilder, defaultF32: Float) = builder.addFloat(26, defaultF32, 42.0)
|
||||
fun addJustF64(builder: FlatBufferBuilder, justF64: Double) = builder.addDouble(27, justF64, 0.0)
|
||||
fun addMaybeF64(builder: FlatBufferBuilder, maybeF64: Double) = builder.addDouble(28, maybeF64, 0.0)
|
||||
fun addDefaultF64(builder: FlatBufferBuilder, defaultF64: Double) = builder.addDouble(29, defaultF64, 42.0)
|
||||
fun addJustBool(builder: FlatBufferBuilder, justBool: Boolean) = builder.addBoolean(30, justBool, false)
|
||||
fun addMaybeBool(builder: FlatBufferBuilder, maybeBool: Boolean) = builder.addBoolean(31, maybeBool, false)
|
||||
fun addDefaultBool(builder: FlatBufferBuilder, defaultBool: Boolean) = builder.addBoolean(32, defaultBool, true)
|
||||
fun addJustEnum(builder: FlatBufferBuilder, justEnum: Byte) = builder.addByte(33, justEnum, 0)
|
||||
fun addMaybeEnum(builder: FlatBufferBuilder, maybeEnum: Byte) = builder.addByte(34, maybeEnum, 0)
|
||||
fun addDefaultEnum(builder: FlatBufferBuilder, defaultEnum: Byte) = builder.addByte(35, defaultEnum, 1)
|
||||
fun endScalarStuff(builder: FlatBufferBuilder) : Int {
|
||||
val o = builder.endTable()
|
||||
return o
|
||||
}
|
||||
fun finishScalarStuffBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset, "NULL")
|
||||
fun finishSizePrefixedScalarStuffBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset, "NULL")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,331 @@
|
||||
#[ optional_scalars.ScalarStuff
|
||||
Automatically generated by the FlatBuffers compiler, do not modify.
|
||||
Or modify. I'm a message, not a cop.
|
||||
|
||||
flatc version: 24.3.25
|
||||
|
||||
Declared by :
|
||||
Rooting type : optional_scalars.ScalarStuff ()
|
||||
]#
|
||||
|
||||
import OptionalByte as optional_scalars_OptionalByte
|
||||
import flatbuffers
|
||||
import std/options
|
||||
|
||||
type ScalarStuff* = object of FlatObj
|
||||
func justI8*(self: ScalarStuff): int8 =
|
||||
let o = self.tab.Offset(4)
|
||||
if o != 0:
|
||||
return Get[int8](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justI8=`*(self: var ScalarStuff, n: int8): bool =
|
||||
return self.tab.MutateSlot(4, n)
|
||||
func maybeI8*(self: ScalarStuff): Option[int8] =
|
||||
let o = self.tab.Offset(6)
|
||||
if o != 0:
|
||||
return some(Get[int8](self.tab, self.tab.Pos + o))
|
||||
func `maybeI8=`*(self: var ScalarStuff, n: Option[int8]): bool =
|
||||
return self.tab.MutateSlot(6, n)
|
||||
func defaultI8*(self: ScalarStuff): int8 =
|
||||
let o = self.tab.Offset(8)
|
||||
if o != 0:
|
||||
return Get[int8](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultI8=`*(self: var ScalarStuff, n: int8): bool =
|
||||
return self.tab.MutateSlot(8, n)
|
||||
func justU8*(self: ScalarStuff): uint8 =
|
||||
let o = self.tab.Offset(10)
|
||||
if o != 0:
|
||||
return Get[uint8](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justU8=`*(self: var ScalarStuff, n: uint8): bool =
|
||||
return self.tab.MutateSlot(10, n)
|
||||
func maybeU8*(self: ScalarStuff): Option[uint8] =
|
||||
let o = self.tab.Offset(12)
|
||||
if o != 0:
|
||||
return some(Get[uint8](self.tab, self.tab.Pos + o))
|
||||
func `maybeU8=`*(self: var ScalarStuff, n: Option[uint8]): bool =
|
||||
return self.tab.MutateSlot(12, n)
|
||||
func defaultU8*(self: ScalarStuff): uint8 =
|
||||
let o = self.tab.Offset(14)
|
||||
if o != 0:
|
||||
return Get[uint8](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultU8=`*(self: var ScalarStuff, n: uint8): bool =
|
||||
return self.tab.MutateSlot(14, n)
|
||||
func justI16*(self: ScalarStuff): int16 =
|
||||
let o = self.tab.Offset(16)
|
||||
if o != 0:
|
||||
return Get[int16](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justI16=`*(self: var ScalarStuff, n: int16): bool =
|
||||
return self.tab.MutateSlot(16, n)
|
||||
func maybeI16*(self: ScalarStuff): Option[int16] =
|
||||
let o = self.tab.Offset(18)
|
||||
if o != 0:
|
||||
return some(Get[int16](self.tab, self.tab.Pos + o))
|
||||
func `maybeI16=`*(self: var ScalarStuff, n: Option[int16]): bool =
|
||||
return self.tab.MutateSlot(18, n)
|
||||
func defaultI16*(self: ScalarStuff): int16 =
|
||||
let o = self.tab.Offset(20)
|
||||
if o != 0:
|
||||
return Get[int16](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultI16=`*(self: var ScalarStuff, n: int16): bool =
|
||||
return self.tab.MutateSlot(20, n)
|
||||
func justU16*(self: ScalarStuff): uint16 =
|
||||
let o = self.tab.Offset(22)
|
||||
if o != 0:
|
||||
return Get[uint16](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justU16=`*(self: var ScalarStuff, n: uint16): bool =
|
||||
return self.tab.MutateSlot(22, n)
|
||||
func maybeU16*(self: ScalarStuff): Option[uint16] =
|
||||
let o = self.tab.Offset(24)
|
||||
if o != 0:
|
||||
return some(Get[uint16](self.tab, self.tab.Pos + o))
|
||||
func `maybeU16=`*(self: var ScalarStuff, n: Option[uint16]): bool =
|
||||
return self.tab.MutateSlot(24, n)
|
||||
func defaultU16*(self: ScalarStuff): uint16 =
|
||||
let o = self.tab.Offset(26)
|
||||
if o != 0:
|
||||
return Get[uint16](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultU16=`*(self: var ScalarStuff, n: uint16): bool =
|
||||
return self.tab.MutateSlot(26, n)
|
||||
func justI32*(self: ScalarStuff): int32 =
|
||||
let o = self.tab.Offset(28)
|
||||
if o != 0:
|
||||
return Get[int32](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justI32=`*(self: var ScalarStuff, n: int32): bool =
|
||||
return self.tab.MutateSlot(28, n)
|
||||
func maybeI32*(self: ScalarStuff): Option[int32] =
|
||||
let o = self.tab.Offset(30)
|
||||
if o != 0:
|
||||
return some(Get[int32](self.tab, self.tab.Pos + o))
|
||||
func `maybeI32=`*(self: var ScalarStuff, n: Option[int32]): bool =
|
||||
return self.tab.MutateSlot(30, n)
|
||||
func defaultI32*(self: ScalarStuff): int32 =
|
||||
let o = self.tab.Offset(32)
|
||||
if o != 0:
|
||||
return Get[int32](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultI32=`*(self: var ScalarStuff, n: int32): bool =
|
||||
return self.tab.MutateSlot(32, n)
|
||||
func justU32*(self: ScalarStuff): uint32 =
|
||||
let o = self.tab.Offset(34)
|
||||
if o != 0:
|
||||
return Get[uint32](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justU32=`*(self: var ScalarStuff, n: uint32): bool =
|
||||
return self.tab.MutateSlot(34, n)
|
||||
func maybeU32*(self: ScalarStuff): Option[uint32] =
|
||||
let o = self.tab.Offset(36)
|
||||
if o != 0:
|
||||
return some(Get[uint32](self.tab, self.tab.Pos + o))
|
||||
func `maybeU32=`*(self: var ScalarStuff, n: Option[uint32]): bool =
|
||||
return self.tab.MutateSlot(36, n)
|
||||
func defaultU32*(self: ScalarStuff): uint32 =
|
||||
let o = self.tab.Offset(38)
|
||||
if o != 0:
|
||||
return Get[uint32](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultU32=`*(self: var ScalarStuff, n: uint32): bool =
|
||||
return self.tab.MutateSlot(38, n)
|
||||
func justI64*(self: ScalarStuff): int64 =
|
||||
let o = self.tab.Offset(40)
|
||||
if o != 0:
|
||||
return Get[int64](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justI64=`*(self: var ScalarStuff, n: int64): bool =
|
||||
return self.tab.MutateSlot(40, n)
|
||||
func maybeI64*(self: ScalarStuff): Option[int64] =
|
||||
let o = self.tab.Offset(42)
|
||||
if o != 0:
|
||||
return some(Get[int64](self.tab, self.tab.Pos + o))
|
||||
func `maybeI64=`*(self: var ScalarStuff, n: Option[int64]): bool =
|
||||
return self.tab.MutateSlot(42, n)
|
||||
func defaultI64*(self: ScalarStuff): int64 =
|
||||
let o = self.tab.Offset(44)
|
||||
if o != 0:
|
||||
return Get[int64](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultI64=`*(self: var ScalarStuff, n: int64): bool =
|
||||
return self.tab.MutateSlot(44, n)
|
||||
func justU64*(self: ScalarStuff): uint64 =
|
||||
let o = self.tab.Offset(46)
|
||||
if o != 0:
|
||||
return Get[uint64](self.tab, self.tab.Pos + o)
|
||||
return 0
|
||||
func `justU64=`*(self: var ScalarStuff, n: uint64): bool =
|
||||
return self.tab.MutateSlot(46, n)
|
||||
func maybeU64*(self: ScalarStuff): Option[uint64] =
|
||||
let o = self.tab.Offset(48)
|
||||
if o != 0:
|
||||
return some(Get[uint64](self.tab, self.tab.Pos + o))
|
||||
func `maybeU64=`*(self: var ScalarStuff, n: Option[uint64]): bool =
|
||||
return self.tab.MutateSlot(48, n)
|
||||
func defaultU64*(self: ScalarStuff): uint64 =
|
||||
let o = self.tab.Offset(50)
|
||||
if o != 0:
|
||||
return Get[uint64](self.tab, self.tab.Pos + o)
|
||||
return 42
|
||||
func `defaultU64=`*(self: var ScalarStuff, n: uint64): bool =
|
||||
return self.tab.MutateSlot(50, n)
|
||||
func justF32*(self: ScalarStuff): float32 =
|
||||
let o = self.tab.Offset(52)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return 0.0
|
||||
func `justF32=`*(self: var ScalarStuff, n: float32): bool =
|
||||
return self.tab.MutateSlot(52, n)
|
||||
func maybeF32*(self: ScalarStuff): Option[float32] =
|
||||
let o = self.tab.Offset(54)
|
||||
if o != 0:
|
||||
return some(Get[float32](self.tab, self.tab.Pos + o))
|
||||
func `maybeF32=`*(self: var ScalarStuff, n: Option[float32]): bool =
|
||||
return self.tab.MutateSlot(54, n)
|
||||
func defaultF32*(self: ScalarStuff): float32 =
|
||||
let o = self.tab.Offset(56)
|
||||
if o != 0:
|
||||
return Get[float32](self.tab, self.tab.Pos + o)
|
||||
return 42.0
|
||||
func `defaultF32=`*(self: var ScalarStuff, n: float32): bool =
|
||||
return self.tab.MutateSlot(56, n)
|
||||
func justF64*(self: ScalarStuff): float64 =
|
||||
let o = self.tab.Offset(58)
|
||||
if o != 0:
|
||||
return Get[float64](self.tab, self.tab.Pos + o)
|
||||
return 0.0
|
||||
func `justF64=`*(self: var ScalarStuff, n: float64): bool =
|
||||
return self.tab.MutateSlot(58, n)
|
||||
func maybeF64*(self: ScalarStuff): Option[float64] =
|
||||
let o = self.tab.Offset(60)
|
||||
if o != 0:
|
||||
return some(Get[float64](self.tab, self.tab.Pos + o))
|
||||
func `maybeF64=`*(self: var ScalarStuff, n: Option[float64]): bool =
|
||||
return self.tab.MutateSlot(60, n)
|
||||
func defaultF64*(self: ScalarStuff): float64 =
|
||||
let o = self.tab.Offset(62)
|
||||
if o != 0:
|
||||
return Get[float64](self.tab, self.tab.Pos + o)
|
||||
return 42.0
|
||||
func `defaultF64=`*(self: var ScalarStuff, n: float64): bool =
|
||||
return self.tab.MutateSlot(62, n)
|
||||
func justBool*(self: ScalarStuff): bool =
|
||||
let o = self.tab.Offset(64)
|
||||
if o != 0:
|
||||
return Get[bool](self.tab, self.tab.Pos + o)
|
||||
return false
|
||||
func `justBool=`*(self: var ScalarStuff, n: bool): bool =
|
||||
return self.tab.MutateSlot(64, n)
|
||||
func maybeBool*(self: ScalarStuff): Option[bool] =
|
||||
let o = self.tab.Offset(66)
|
||||
if o != 0:
|
||||
return some(Get[bool](self.tab, self.tab.Pos + o))
|
||||
func `maybeBool=`*(self: var ScalarStuff, n: Option[bool]): bool =
|
||||
return self.tab.MutateSlot(66, n)
|
||||
func defaultBool*(self: ScalarStuff): bool =
|
||||
let o = self.tab.Offset(68)
|
||||
if o != 0:
|
||||
return Get[bool](self.tab, self.tab.Pos + o)
|
||||
return true
|
||||
func `defaultBool=`*(self: var ScalarStuff, n: bool): bool =
|
||||
return self.tab.MutateSlot(68, n)
|
||||
func justEnum*(self: ScalarStuff): optional_scalars_OptionalByte.OptionalByte =
|
||||
let o = self.tab.Offset(70)
|
||||
if o != 0:
|
||||
return optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o))
|
||||
return type(result)(0)
|
||||
func `justEnum=`*(self: var ScalarStuff, n: optional_scalars_OptionalByte.OptionalByte): bool =
|
||||
return self.tab.MutateSlot(70, n)
|
||||
func maybeEnum*(self: ScalarStuff): Option[optional_scalars_OptionalByte.OptionalByte] =
|
||||
let o = self.tab.Offset(72)
|
||||
if o != 0:
|
||||
return some(optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o)))
|
||||
func `maybeEnum=`*(self: var ScalarStuff, n: Option[optional_scalars_OptionalByte.OptionalByte]): bool =
|
||||
return self.tab.MutateSlot(72, n)
|
||||
func defaultEnum*(self: ScalarStuff): optional_scalars_OptionalByte.OptionalByte =
|
||||
let o = self.tab.Offset(74)
|
||||
if o != 0:
|
||||
return optional_scalars_OptionalByte.OptionalByte(Get[int8](self.tab, self.tab.Pos + o))
|
||||
return type(result)(1)
|
||||
func `defaultEnum=`*(self: var ScalarStuff, n: optional_scalars_OptionalByte.OptionalByte): bool =
|
||||
return self.tab.MutateSlot(74, n)
|
||||
proc ScalarStuffStart*(builder: var Builder) =
|
||||
builder.StartObject(36)
|
||||
proc ScalarStuffAddjustI8*(builder: var Builder, justI8: int8) =
|
||||
builder.PrependSlot(0, justI8, default(int8))
|
||||
proc ScalarStuffAddmaybeI8*(builder: var Builder, maybeI8: int8) =
|
||||
builder.PrependSlot(1, maybeI8, default(int8))
|
||||
proc ScalarStuffAdddefaultI8*(builder: var Builder, defaultI8: int8) =
|
||||
builder.PrependSlot(2, defaultI8, default(int8))
|
||||
proc ScalarStuffAddjustU8*(builder: var Builder, justU8: uint8) =
|
||||
builder.PrependSlot(3, justU8, default(uint8))
|
||||
proc ScalarStuffAddmaybeU8*(builder: var Builder, maybeU8: uint8) =
|
||||
builder.PrependSlot(4, maybeU8, default(uint8))
|
||||
proc ScalarStuffAdddefaultU8*(builder: var Builder, defaultU8: uint8) =
|
||||
builder.PrependSlot(5, defaultU8, default(uint8))
|
||||
proc ScalarStuffAddjustI16*(builder: var Builder, justI16: int16) =
|
||||
builder.PrependSlot(6, justI16, default(int16))
|
||||
proc ScalarStuffAddmaybeI16*(builder: var Builder, maybeI16: int16) =
|
||||
builder.PrependSlot(7, maybeI16, default(int16))
|
||||
proc ScalarStuffAdddefaultI16*(builder: var Builder, defaultI16: int16) =
|
||||
builder.PrependSlot(8, defaultI16, default(int16))
|
||||
proc ScalarStuffAddjustU16*(builder: var Builder, justU16: uint16) =
|
||||
builder.PrependSlot(9, justU16, default(uint16))
|
||||
proc ScalarStuffAddmaybeU16*(builder: var Builder, maybeU16: uint16) =
|
||||
builder.PrependSlot(10, maybeU16, default(uint16))
|
||||
proc ScalarStuffAdddefaultU16*(builder: var Builder, defaultU16: uint16) =
|
||||
builder.PrependSlot(11, defaultU16, default(uint16))
|
||||
proc ScalarStuffAddjustI32*(builder: var Builder, justI32: int32) =
|
||||
builder.PrependSlot(12, justI32, default(int32))
|
||||
proc ScalarStuffAddmaybeI32*(builder: var Builder, maybeI32: int32) =
|
||||
builder.PrependSlot(13, maybeI32, default(int32))
|
||||
proc ScalarStuffAdddefaultI32*(builder: var Builder, defaultI32: int32) =
|
||||
builder.PrependSlot(14, defaultI32, default(int32))
|
||||
proc ScalarStuffAddjustU32*(builder: var Builder, justU32: uint32) =
|
||||
builder.PrependSlot(15, justU32, default(uint32))
|
||||
proc ScalarStuffAddmaybeU32*(builder: var Builder, maybeU32: uint32) =
|
||||
builder.PrependSlot(16, maybeU32, default(uint32))
|
||||
proc ScalarStuffAdddefaultU32*(builder: var Builder, defaultU32: uint32) =
|
||||
builder.PrependSlot(17, defaultU32, default(uint32))
|
||||
proc ScalarStuffAddjustI64*(builder: var Builder, justI64: int64) =
|
||||
builder.PrependSlot(18, justI64, default(int64))
|
||||
proc ScalarStuffAddmaybeI64*(builder: var Builder, maybeI64: int64) =
|
||||
builder.PrependSlot(19, maybeI64, default(int64))
|
||||
proc ScalarStuffAdddefaultI64*(builder: var Builder, defaultI64: int64) =
|
||||
builder.PrependSlot(20, defaultI64, default(int64))
|
||||
proc ScalarStuffAddjustU64*(builder: var Builder, justU64: uint64) =
|
||||
builder.PrependSlot(21, justU64, default(uint64))
|
||||
proc ScalarStuffAddmaybeU64*(builder: var Builder, maybeU64: uint64) =
|
||||
builder.PrependSlot(22, maybeU64, default(uint64))
|
||||
proc ScalarStuffAdddefaultU64*(builder: var Builder, defaultU64: uint64) =
|
||||
builder.PrependSlot(23, defaultU64, default(uint64))
|
||||
proc ScalarStuffAddjustF32*(builder: var Builder, justF32: float32) =
|
||||
builder.PrependSlot(24, justF32, default(float32))
|
||||
proc ScalarStuffAddmaybeF32*(builder: var Builder, maybeF32: float32) =
|
||||
builder.PrependSlot(25, maybeF32, default(float32))
|
||||
proc ScalarStuffAdddefaultF32*(builder: var Builder, defaultF32: float32) =
|
||||
builder.PrependSlot(26, defaultF32, default(float32))
|
||||
proc ScalarStuffAddjustF64*(builder: var Builder, justF64: float64) =
|
||||
builder.PrependSlot(27, justF64, default(float64))
|
||||
proc ScalarStuffAddmaybeF64*(builder: var Builder, maybeF64: float64) =
|
||||
builder.PrependSlot(28, maybeF64, default(float64))
|
||||
proc ScalarStuffAdddefaultF64*(builder: var Builder, defaultF64: float64) =
|
||||
builder.PrependSlot(29, defaultF64, default(float64))
|
||||
proc ScalarStuffAddjustBool*(builder: var Builder, justBool: bool) =
|
||||
builder.PrependSlot(30, justBool, default(bool))
|
||||
proc ScalarStuffAddmaybeBool*(builder: var Builder, maybeBool: bool) =
|
||||
builder.PrependSlot(31, maybeBool, default(bool))
|
||||
proc ScalarStuffAdddefaultBool*(builder: var Builder, defaultBool: bool) =
|
||||
builder.PrependSlot(32, defaultBool, default(bool))
|
||||
proc ScalarStuffAddjustEnum*(builder: var Builder, justEnum: int8) =
|
||||
builder.PrependSlot(33, justEnum, default(int8))
|
||||
proc ScalarStuffAddmaybeEnum*(builder: var Builder, maybeEnum: int8) =
|
||||
builder.PrependSlot(34, maybeEnum, default(int8))
|
||||
proc ScalarStuffAdddefaultEnum*(builder: var Builder, defaultEnum: int8) =
|
||||
builder.PrependSlot(35, defaultEnum, default(int8))
|
||||
proc ScalarStuffEnd*(builder: var Builder): uoffset =
|
||||
return builder.EndObject()
|
||||
@@ -0,0 +1,651 @@
|
||||
# automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
# namespace: optional_scalars
|
||||
|
||||
import flatbuffers
|
||||
from flatbuffers.compat import import_numpy
|
||||
np = import_numpy()
|
||||
|
||||
class ScalarStuff(object):
|
||||
__slots__ = ['_tab']
|
||||
|
||||
@classmethod
|
||||
def GetRootAs(cls, buf, offset=0):
|
||||
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
|
||||
x = ScalarStuff()
|
||||
x.Init(buf, n + offset)
|
||||
return x
|
||||
|
||||
@classmethod
|
||||
def GetRootAsScalarStuff(cls, buf, offset=0):
|
||||
"""This method is deprecated. Please switch to GetRootAs."""
|
||||
return cls.GetRootAs(buf, offset)
|
||||
@classmethod
|
||||
def ScalarStuffBufferHasIdentifier(cls, buf, offset, size_prefixed=False):
|
||||
return flatbuffers.util.BufferHasIdentifier(buf, offset, b"\x4E\x55\x4C\x4C", size_prefixed=size_prefixed)
|
||||
|
||||
# ScalarStuff
|
||||
def Init(self, buf, pos):
|
||||
self._tab = flatbuffers.table.Table(buf, pos)
|
||||
|
||||
# ScalarStuff
|
||||
def JustI8(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeI8(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultI8(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustU8(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeU8(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultU8(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustI16(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeI16(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultI16(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustU16(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeU16(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultU16(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustI32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(28))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeI32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(30))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultI32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(32))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustU32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(34))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeU32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(36))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultU32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(38))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustI64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(40))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeI64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(42))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultI64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(44))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustU64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(46))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeU64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(48))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultU64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(50))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos)
|
||||
return 42
|
||||
|
||||
# ScalarStuff
|
||||
def JustF32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(52))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return 0.0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeF32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(54))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultF32(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(56))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
|
||||
return 42.0
|
||||
|
||||
# ScalarStuff
|
||||
def JustF64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(58))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
||||
return 0.0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeF64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(60))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultF64(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(62))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos)
|
||||
return 42.0
|
||||
|
||||
# ScalarStuff
|
||||
def JustBool(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(64))
|
||||
if o != 0:
|
||||
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
||||
return False
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeBool(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(66))
|
||||
if o != 0:
|
||||
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultBool(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(68))
|
||||
if o != 0:
|
||||
return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
|
||||
return True
|
||||
|
||||
# ScalarStuff
|
||||
def JustEnum(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(70))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
||||
return 0
|
||||
|
||||
# ScalarStuff
|
||||
def MaybeEnum(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(72))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
||||
return None
|
||||
|
||||
# ScalarStuff
|
||||
def DefaultEnum(self):
|
||||
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(74))
|
||||
if o != 0:
|
||||
return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
|
||||
return 1
|
||||
|
||||
def ScalarStuffStart(builder):
|
||||
builder.StartObject(36)
|
||||
|
||||
def Start(builder):
|
||||
ScalarStuffStart(builder)
|
||||
|
||||
def ScalarStuffAddJustI8(builder, justI8):
|
||||
builder.PrependInt8Slot(0, justI8, 0)
|
||||
|
||||
def AddJustI8(builder, justI8):
|
||||
ScalarStuffAddJustI8(builder, justI8)
|
||||
|
||||
def ScalarStuffAddMaybeI8(builder, maybeI8):
|
||||
builder.PrependInt8Slot(1, maybeI8, None)
|
||||
|
||||
def AddMaybeI8(builder, maybeI8):
|
||||
ScalarStuffAddMaybeI8(builder, maybeI8)
|
||||
|
||||
def ScalarStuffAddDefaultI8(builder, defaultI8):
|
||||
builder.PrependInt8Slot(2, defaultI8, 42)
|
||||
|
||||
def AddDefaultI8(builder, defaultI8):
|
||||
ScalarStuffAddDefaultI8(builder, defaultI8)
|
||||
|
||||
def ScalarStuffAddJustU8(builder, justU8):
|
||||
builder.PrependUint8Slot(3, justU8, 0)
|
||||
|
||||
def AddJustU8(builder, justU8):
|
||||
ScalarStuffAddJustU8(builder, justU8)
|
||||
|
||||
def ScalarStuffAddMaybeU8(builder, maybeU8):
|
||||
builder.PrependUint8Slot(4, maybeU8, None)
|
||||
|
||||
def AddMaybeU8(builder, maybeU8):
|
||||
ScalarStuffAddMaybeU8(builder, maybeU8)
|
||||
|
||||
def ScalarStuffAddDefaultU8(builder, defaultU8):
|
||||
builder.PrependUint8Slot(5, defaultU8, 42)
|
||||
|
||||
def AddDefaultU8(builder, defaultU8):
|
||||
ScalarStuffAddDefaultU8(builder, defaultU8)
|
||||
|
||||
def ScalarStuffAddJustI16(builder, justI16):
|
||||
builder.PrependInt16Slot(6, justI16, 0)
|
||||
|
||||
def AddJustI16(builder, justI16):
|
||||
ScalarStuffAddJustI16(builder, justI16)
|
||||
|
||||
def ScalarStuffAddMaybeI16(builder, maybeI16):
|
||||
builder.PrependInt16Slot(7, maybeI16, None)
|
||||
|
||||
def AddMaybeI16(builder, maybeI16):
|
||||
ScalarStuffAddMaybeI16(builder, maybeI16)
|
||||
|
||||
def ScalarStuffAddDefaultI16(builder, defaultI16):
|
||||
builder.PrependInt16Slot(8, defaultI16, 42)
|
||||
|
||||
def AddDefaultI16(builder, defaultI16):
|
||||
ScalarStuffAddDefaultI16(builder, defaultI16)
|
||||
|
||||
def ScalarStuffAddJustU16(builder, justU16):
|
||||
builder.PrependUint16Slot(9, justU16, 0)
|
||||
|
||||
def AddJustU16(builder, justU16):
|
||||
ScalarStuffAddJustU16(builder, justU16)
|
||||
|
||||
def ScalarStuffAddMaybeU16(builder, maybeU16):
|
||||
builder.PrependUint16Slot(10, maybeU16, None)
|
||||
|
||||
def AddMaybeU16(builder, maybeU16):
|
||||
ScalarStuffAddMaybeU16(builder, maybeU16)
|
||||
|
||||
def ScalarStuffAddDefaultU16(builder, defaultU16):
|
||||
builder.PrependUint16Slot(11, defaultU16, 42)
|
||||
|
||||
def AddDefaultU16(builder, defaultU16):
|
||||
ScalarStuffAddDefaultU16(builder, defaultU16)
|
||||
|
||||
def ScalarStuffAddJustI32(builder, justI32):
|
||||
builder.PrependInt32Slot(12, justI32, 0)
|
||||
|
||||
def AddJustI32(builder, justI32):
|
||||
ScalarStuffAddJustI32(builder, justI32)
|
||||
|
||||
def ScalarStuffAddMaybeI32(builder, maybeI32):
|
||||
builder.PrependInt32Slot(13, maybeI32, None)
|
||||
|
||||
def AddMaybeI32(builder, maybeI32):
|
||||
ScalarStuffAddMaybeI32(builder, maybeI32)
|
||||
|
||||
def ScalarStuffAddDefaultI32(builder, defaultI32):
|
||||
builder.PrependInt32Slot(14, defaultI32, 42)
|
||||
|
||||
def AddDefaultI32(builder, defaultI32):
|
||||
ScalarStuffAddDefaultI32(builder, defaultI32)
|
||||
|
||||
def ScalarStuffAddJustU32(builder, justU32):
|
||||
builder.PrependUint32Slot(15, justU32, 0)
|
||||
|
||||
def AddJustU32(builder, justU32):
|
||||
ScalarStuffAddJustU32(builder, justU32)
|
||||
|
||||
def ScalarStuffAddMaybeU32(builder, maybeU32):
|
||||
builder.PrependUint32Slot(16, maybeU32, None)
|
||||
|
||||
def AddMaybeU32(builder, maybeU32):
|
||||
ScalarStuffAddMaybeU32(builder, maybeU32)
|
||||
|
||||
def ScalarStuffAddDefaultU32(builder, defaultU32):
|
||||
builder.PrependUint32Slot(17, defaultU32, 42)
|
||||
|
||||
def AddDefaultU32(builder, defaultU32):
|
||||
ScalarStuffAddDefaultU32(builder, defaultU32)
|
||||
|
||||
def ScalarStuffAddJustI64(builder, justI64):
|
||||
builder.PrependInt64Slot(18, justI64, 0)
|
||||
|
||||
def AddJustI64(builder, justI64):
|
||||
ScalarStuffAddJustI64(builder, justI64)
|
||||
|
||||
def ScalarStuffAddMaybeI64(builder, maybeI64):
|
||||
builder.PrependInt64Slot(19, maybeI64, None)
|
||||
|
||||
def AddMaybeI64(builder, maybeI64):
|
||||
ScalarStuffAddMaybeI64(builder, maybeI64)
|
||||
|
||||
def ScalarStuffAddDefaultI64(builder, defaultI64):
|
||||
builder.PrependInt64Slot(20, defaultI64, 42)
|
||||
|
||||
def AddDefaultI64(builder, defaultI64):
|
||||
ScalarStuffAddDefaultI64(builder, defaultI64)
|
||||
|
||||
def ScalarStuffAddJustU64(builder, justU64):
|
||||
builder.PrependUint64Slot(21, justU64, 0)
|
||||
|
||||
def AddJustU64(builder, justU64):
|
||||
ScalarStuffAddJustU64(builder, justU64)
|
||||
|
||||
def ScalarStuffAddMaybeU64(builder, maybeU64):
|
||||
builder.PrependUint64Slot(22, maybeU64, None)
|
||||
|
||||
def AddMaybeU64(builder, maybeU64):
|
||||
ScalarStuffAddMaybeU64(builder, maybeU64)
|
||||
|
||||
def ScalarStuffAddDefaultU64(builder, defaultU64):
|
||||
builder.PrependUint64Slot(23, defaultU64, 42)
|
||||
|
||||
def AddDefaultU64(builder, defaultU64):
|
||||
ScalarStuffAddDefaultU64(builder, defaultU64)
|
||||
|
||||
def ScalarStuffAddJustF32(builder, justF32):
|
||||
builder.PrependFloat32Slot(24, justF32, 0.0)
|
||||
|
||||
def AddJustF32(builder, justF32):
|
||||
ScalarStuffAddJustF32(builder, justF32)
|
||||
|
||||
def ScalarStuffAddMaybeF32(builder, maybeF32):
|
||||
builder.PrependFloat32Slot(25, maybeF32, None)
|
||||
|
||||
def AddMaybeF32(builder, maybeF32):
|
||||
ScalarStuffAddMaybeF32(builder, maybeF32)
|
||||
|
||||
def ScalarStuffAddDefaultF32(builder, defaultF32):
|
||||
builder.PrependFloat32Slot(26, defaultF32, 42.0)
|
||||
|
||||
def AddDefaultF32(builder, defaultF32):
|
||||
ScalarStuffAddDefaultF32(builder, defaultF32)
|
||||
|
||||
def ScalarStuffAddJustF64(builder, justF64):
|
||||
builder.PrependFloat64Slot(27, justF64, 0.0)
|
||||
|
||||
def AddJustF64(builder, justF64):
|
||||
ScalarStuffAddJustF64(builder, justF64)
|
||||
|
||||
def ScalarStuffAddMaybeF64(builder, maybeF64):
|
||||
builder.PrependFloat64Slot(28, maybeF64, None)
|
||||
|
||||
def AddMaybeF64(builder, maybeF64):
|
||||
ScalarStuffAddMaybeF64(builder, maybeF64)
|
||||
|
||||
def ScalarStuffAddDefaultF64(builder, defaultF64):
|
||||
builder.PrependFloat64Slot(29, defaultF64, 42.0)
|
||||
|
||||
def AddDefaultF64(builder, defaultF64):
|
||||
ScalarStuffAddDefaultF64(builder, defaultF64)
|
||||
|
||||
def ScalarStuffAddJustBool(builder, justBool):
|
||||
builder.PrependBoolSlot(30, justBool, 0)
|
||||
|
||||
def AddJustBool(builder, justBool):
|
||||
ScalarStuffAddJustBool(builder, justBool)
|
||||
|
||||
def ScalarStuffAddMaybeBool(builder, maybeBool):
|
||||
builder.PrependBoolSlot(31, maybeBool, None)
|
||||
|
||||
def AddMaybeBool(builder, maybeBool):
|
||||
ScalarStuffAddMaybeBool(builder, maybeBool)
|
||||
|
||||
def ScalarStuffAddDefaultBool(builder, defaultBool):
|
||||
builder.PrependBoolSlot(32, defaultBool, 1)
|
||||
|
||||
def AddDefaultBool(builder, defaultBool):
|
||||
ScalarStuffAddDefaultBool(builder, defaultBool)
|
||||
|
||||
def ScalarStuffAddJustEnum(builder, justEnum):
|
||||
builder.PrependInt8Slot(33, justEnum, 0)
|
||||
|
||||
def AddJustEnum(builder, justEnum):
|
||||
ScalarStuffAddJustEnum(builder, justEnum)
|
||||
|
||||
def ScalarStuffAddMaybeEnum(builder, maybeEnum):
|
||||
builder.PrependInt8Slot(34, maybeEnum, None)
|
||||
|
||||
def AddMaybeEnum(builder, maybeEnum):
|
||||
ScalarStuffAddMaybeEnum(builder, maybeEnum)
|
||||
|
||||
def ScalarStuffAddDefaultEnum(builder, defaultEnum):
|
||||
builder.PrependInt8Slot(35, defaultEnum, 1)
|
||||
|
||||
def AddDefaultEnum(builder, defaultEnum):
|
||||
ScalarStuffAddDefaultEnum(builder, defaultEnum)
|
||||
|
||||
def ScalarStuffEnd(builder):
|
||||
return builder.EndObject()
|
||||
|
||||
def End(builder):
|
||||
return ScalarStuffEnd(builder)
|
||||
|
||||
|
||||
class ScalarStuffT(object):
|
||||
|
||||
# ScalarStuffT
|
||||
def __init__(self):
|
||||
self.justI8 = 0 # type: int
|
||||
self.maybeI8 = None # type: Optional[int]
|
||||
self.defaultI8 = 42 # type: int
|
||||
self.justU8 = 0 # type: int
|
||||
self.maybeU8 = None # type: Optional[int]
|
||||
self.defaultU8 = 42 # type: int
|
||||
self.justI16 = 0 # type: int
|
||||
self.maybeI16 = None # type: Optional[int]
|
||||
self.defaultI16 = 42 # type: int
|
||||
self.justU16 = 0 # type: int
|
||||
self.maybeU16 = None # type: Optional[int]
|
||||
self.defaultU16 = 42 # type: int
|
||||
self.justI32 = 0 # type: int
|
||||
self.maybeI32 = None # type: Optional[int]
|
||||
self.defaultI32 = 42 # type: int
|
||||
self.justU32 = 0 # type: int
|
||||
self.maybeU32 = None # type: Optional[int]
|
||||
self.defaultU32 = 42 # type: int
|
||||
self.justI64 = 0 # type: int
|
||||
self.maybeI64 = None # type: Optional[int]
|
||||
self.defaultI64 = 42 # type: int
|
||||
self.justU64 = 0 # type: int
|
||||
self.maybeU64 = None # type: Optional[int]
|
||||
self.defaultU64 = 42 # type: int
|
||||
self.justF32 = 0.0 # type: float
|
||||
self.maybeF32 = None # type: Optional[float]
|
||||
self.defaultF32 = 42.0 # type: float
|
||||
self.justF64 = 0.0 # type: float
|
||||
self.maybeF64 = None # type: Optional[float]
|
||||
self.defaultF64 = 42.0 # type: float
|
||||
self.justBool = False # type: bool
|
||||
self.maybeBool = None # type: Optional[bool]
|
||||
self.defaultBool = True # type: bool
|
||||
self.justEnum = 0 # type: int
|
||||
self.maybeEnum = None # type: Optional[int]
|
||||
self.defaultEnum = 1 # type: int
|
||||
|
||||
@classmethod
|
||||
def InitFromBuf(cls, buf, pos):
|
||||
scalarStuff = ScalarStuff()
|
||||
scalarStuff.Init(buf, pos)
|
||||
return cls.InitFromObj(scalarStuff)
|
||||
|
||||
@classmethod
|
||||
def InitFromPackedBuf(cls, buf, pos=0):
|
||||
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, pos)
|
||||
return cls.InitFromBuf(buf, pos+n)
|
||||
|
||||
@classmethod
|
||||
def InitFromObj(cls, scalarStuff):
|
||||
x = ScalarStuffT()
|
||||
x._UnPack(scalarStuff)
|
||||
return x
|
||||
|
||||
# ScalarStuffT
|
||||
def _UnPack(self, scalarStuff):
|
||||
if scalarStuff is None:
|
||||
return
|
||||
self.justI8 = scalarStuff.JustI8()
|
||||
self.maybeI8 = scalarStuff.MaybeI8()
|
||||
self.defaultI8 = scalarStuff.DefaultI8()
|
||||
self.justU8 = scalarStuff.JustU8()
|
||||
self.maybeU8 = scalarStuff.MaybeU8()
|
||||
self.defaultU8 = scalarStuff.DefaultU8()
|
||||
self.justI16 = scalarStuff.JustI16()
|
||||
self.maybeI16 = scalarStuff.MaybeI16()
|
||||
self.defaultI16 = scalarStuff.DefaultI16()
|
||||
self.justU16 = scalarStuff.JustU16()
|
||||
self.maybeU16 = scalarStuff.MaybeU16()
|
||||
self.defaultU16 = scalarStuff.DefaultU16()
|
||||
self.justI32 = scalarStuff.JustI32()
|
||||
self.maybeI32 = scalarStuff.MaybeI32()
|
||||
self.defaultI32 = scalarStuff.DefaultI32()
|
||||
self.justU32 = scalarStuff.JustU32()
|
||||
self.maybeU32 = scalarStuff.MaybeU32()
|
||||
self.defaultU32 = scalarStuff.DefaultU32()
|
||||
self.justI64 = scalarStuff.JustI64()
|
||||
self.maybeI64 = scalarStuff.MaybeI64()
|
||||
self.defaultI64 = scalarStuff.DefaultI64()
|
||||
self.justU64 = scalarStuff.JustU64()
|
||||
self.maybeU64 = scalarStuff.MaybeU64()
|
||||
self.defaultU64 = scalarStuff.DefaultU64()
|
||||
self.justF32 = scalarStuff.JustF32()
|
||||
self.maybeF32 = scalarStuff.MaybeF32()
|
||||
self.defaultF32 = scalarStuff.DefaultF32()
|
||||
self.justF64 = scalarStuff.JustF64()
|
||||
self.maybeF64 = scalarStuff.MaybeF64()
|
||||
self.defaultF64 = scalarStuff.DefaultF64()
|
||||
self.justBool = scalarStuff.JustBool()
|
||||
self.maybeBool = scalarStuff.MaybeBool()
|
||||
self.defaultBool = scalarStuff.DefaultBool()
|
||||
self.justEnum = scalarStuff.JustEnum()
|
||||
self.maybeEnum = scalarStuff.MaybeEnum()
|
||||
self.defaultEnum = scalarStuff.DefaultEnum()
|
||||
|
||||
# ScalarStuffT
|
||||
def Pack(self, builder):
|
||||
ScalarStuffStart(builder)
|
||||
ScalarStuffAddJustI8(builder, self.justI8)
|
||||
ScalarStuffAddMaybeI8(builder, self.maybeI8)
|
||||
ScalarStuffAddDefaultI8(builder, self.defaultI8)
|
||||
ScalarStuffAddJustU8(builder, self.justU8)
|
||||
ScalarStuffAddMaybeU8(builder, self.maybeU8)
|
||||
ScalarStuffAddDefaultU8(builder, self.defaultU8)
|
||||
ScalarStuffAddJustI16(builder, self.justI16)
|
||||
ScalarStuffAddMaybeI16(builder, self.maybeI16)
|
||||
ScalarStuffAddDefaultI16(builder, self.defaultI16)
|
||||
ScalarStuffAddJustU16(builder, self.justU16)
|
||||
ScalarStuffAddMaybeU16(builder, self.maybeU16)
|
||||
ScalarStuffAddDefaultU16(builder, self.defaultU16)
|
||||
ScalarStuffAddJustI32(builder, self.justI32)
|
||||
ScalarStuffAddMaybeI32(builder, self.maybeI32)
|
||||
ScalarStuffAddDefaultI32(builder, self.defaultI32)
|
||||
ScalarStuffAddJustU32(builder, self.justU32)
|
||||
ScalarStuffAddMaybeU32(builder, self.maybeU32)
|
||||
ScalarStuffAddDefaultU32(builder, self.defaultU32)
|
||||
ScalarStuffAddJustI64(builder, self.justI64)
|
||||
ScalarStuffAddMaybeI64(builder, self.maybeI64)
|
||||
ScalarStuffAddDefaultI64(builder, self.defaultI64)
|
||||
ScalarStuffAddJustU64(builder, self.justU64)
|
||||
ScalarStuffAddMaybeU64(builder, self.maybeU64)
|
||||
ScalarStuffAddDefaultU64(builder, self.defaultU64)
|
||||
ScalarStuffAddJustF32(builder, self.justF32)
|
||||
ScalarStuffAddMaybeF32(builder, self.maybeF32)
|
||||
ScalarStuffAddDefaultF32(builder, self.defaultF32)
|
||||
ScalarStuffAddJustF64(builder, self.justF64)
|
||||
ScalarStuffAddMaybeF64(builder, self.maybeF64)
|
||||
ScalarStuffAddDefaultF64(builder, self.defaultF64)
|
||||
ScalarStuffAddJustBool(builder, self.justBool)
|
||||
ScalarStuffAddMaybeBool(builder, self.maybeBool)
|
||||
ScalarStuffAddDefaultBool(builder, self.defaultBool)
|
||||
ScalarStuffAddJustEnum(builder, self.justEnum)
|
||||
ScalarStuffAddMaybeEnum(builder, self.maybeEnum)
|
||||
ScalarStuffAddDefaultEnum(builder, self.defaultEnum)
|
||||
scalarStuff = ScalarStuffEnd(builder)
|
||||
return scalarStuff
|
||||
@@ -0,0 +1,9 @@
|
||||
// Automatically generated by the Flatbuffers compiler. Do not modify.
|
||||
// @generated
|
||||
pub mod optional_scalars {
|
||||
use super::*;
|
||||
mod optional_byte_generated;
|
||||
pub use self::optional_byte_generated::*;
|
||||
mod scalar_stuff_generated;
|
||||
pub use self::scalar_stuff_generated::*;
|
||||
} // optional_scalars
|
||||
+100
@@ -0,0 +1,100 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
// @generated
|
||||
extern crate alloc;
|
||||
extern crate flatbuffers;
|
||||
use alloc::boxed::Box;
|
||||
use alloc::string::{String, ToString};
|
||||
use alloc::vec::Vec;
|
||||
use core::mem;
|
||||
use core::cmp::Ordering;
|
||||
use self::flatbuffers::{EndianScalar, Follow};
|
||||
use super::*;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MIN_OPTIONAL_BYTE: i8 = 0;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
pub const ENUM_MAX_OPTIONAL_BYTE: i8 = 2;
|
||||
#[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
|
||||
#[allow(non_camel_case_types)]
|
||||
pub const ENUM_VALUES_OPTIONAL_BYTE: [OptionalByte; 3] = [
|
||||
OptionalByte::None,
|
||||
OptionalByte::One,
|
||||
OptionalByte::Two,
|
||||
];
|
||||
|
||||
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
|
||||
#[repr(transparent)]
|
||||
pub struct OptionalByte(pub i8);
|
||||
#[allow(non_upper_case_globals)]
|
||||
impl OptionalByte {
|
||||
pub const None: Self = Self(0);
|
||||
pub const One: Self = Self(1);
|
||||
pub const Two: Self = Self(2);
|
||||
|
||||
pub const ENUM_MIN: i8 = 0;
|
||||
pub const ENUM_MAX: i8 = 2;
|
||||
pub const ENUM_VALUES: &'static [Self] = &[
|
||||
Self::None,
|
||||
Self::One,
|
||||
Self::Two,
|
||||
];
|
||||
/// Returns the variant's name or "" if unknown.
|
||||
pub fn variant_name(self) -> Option<&'static str> {
|
||||
match self {
|
||||
Self::None => Some("None"),
|
||||
Self::One => Some("One"),
|
||||
Self::Two => Some("Two"),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
impl core::fmt::Debug for OptionalByte {
|
||||
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||
if let Some(name) = self.variant_name() {
|
||||
f.write_str(name)
|
||||
} else {
|
||||
f.write_fmt(format_args!("<UNKNOWN {:?}>", self.0))
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'a> flatbuffers::Follow<'a> for OptionalByte {
|
||||
type Inner = Self;
|
||||
#[inline]
|
||||
unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
|
||||
let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl flatbuffers::Push for OptionalByte {
|
||||
type Output = OptionalByte;
|
||||
#[inline]
|
||||
unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
|
||||
flatbuffers::emplace_scalar::<i8>(dst, self.0);
|
||||
}
|
||||
}
|
||||
|
||||
impl flatbuffers::EndianScalar for OptionalByte {
|
||||
type Scalar = i8;
|
||||
#[inline]
|
||||
fn to_little_endian(self) -> i8 {
|
||||
self.0.to_le()
|
||||
}
|
||||
#[inline]
|
||||
#[allow(clippy::wrong_self_convention)]
|
||||
fn from_little_endian(v: i8) -> Self {
|
||||
let b = i8::from_le(v);
|
||||
Self(b)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a> flatbuffers::Verifiable for OptionalByte {
|
||||
#[inline]
|
||||
fn run_verifier(
|
||||
v: &mut flatbuffers::Verifier, pos: usize
|
||||
) -> Result<(), flatbuffers::InvalidFlatbuffer> {
|
||||
use self::flatbuffers::Verifiable;
|
||||
i8::run_verifier(v, pos)
|
||||
}
|
||||
}
|
||||
|
||||
impl flatbuffers::SimpleToVerifyInSlice for OptionalByte {}
|
||||
+1031
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user