diff --git a/goldens/dart/basic_generated.dart b/goldens/dart/basic_generated.dart new file mode 100644 index 000000000..dabd59601 --- /dev/null +++ b/goldens/dart/basic_generated.dart @@ -0,0 +1,160 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// ignore_for_file: unused_import, unused_field, unused_element, unused_local_variable + +import 'dart:typed_data' show Uint8List; +import 'package:flat_buffers/flat_buffers.dart' as fb; + + +class Galaxy { + Galaxy._(this._bc, this._bcOffset); + factory Galaxy(List bytes) { + final rootRef = fb.BufferContext.fromBytes(bytes); + return reader.read(rootRef, 0); + } + + static const fb.Reader reader = _GalaxyReader(); + + final fb.BufferContext _bc; + final int _bcOffset; + + int get numStars => const fb.Int64Reader().vTableGet(_bc, _bcOffset, 4, 0); + + @override + String toString() { + return 'Galaxy{numStars: ${numStars}}'; + } +} + +class _GalaxyReader extends fb.TableReader { + const _GalaxyReader(); + + @override + Galaxy createObject(fb.BufferContext bc, int offset) => + Galaxy._(bc, offset); +} + +class GalaxyBuilder { + GalaxyBuilder(this.fbBuilder); + + final fb.Builder fbBuilder; + + void begin() { + fbBuilder.startTable(1); + } + + int addNumStars(int? numStars) { + fbBuilder.addInt64(0, numStars); + return fbBuilder.offset; + } + + int finish() { + return fbBuilder.endTable(); + } +} + +class GalaxyObjectBuilder extends fb.ObjectBuilder { + final int? _numStars; + + GalaxyObjectBuilder({ + int? numStars, + }) + : _numStars = numStars; + + /// Finish building, and store into the [fbBuilder]. + @override + int finish(fb.Builder fbBuilder) { + fbBuilder.startTable(1); + fbBuilder.addInt64(0, _numStars); + return fbBuilder.endTable(); + } + + /// Convenience method to serialize to byte list. + @override + Uint8List toBytes([String? fileIdentifier]) { + final fbBuilder = fb.Builder(deduplicateTables: false); + fbBuilder.finish(finish(fbBuilder), fileIdentifier); + return fbBuilder.buffer; + } +} +class Universe { + Universe._(this._bc, this._bcOffset); + factory Universe(List bytes) { + final rootRef = fb.BufferContext.fromBytes(bytes); + return reader.read(rootRef, 0); + } + + static const fb.Reader reader = _UniverseReader(); + + final fb.BufferContext _bc; + final int _bcOffset; + + double get age => const fb.Float64Reader().vTableGet(_bc, _bcOffset, 4, 0.0); + List? get galaxies => const fb.ListReader(Galaxy.reader).vTableGetNullable(_bc, _bcOffset, 6); + + @override + String toString() { + return 'Universe{age: ${age}, galaxies: ${galaxies}}'; + } +} + +class _UniverseReader extends fb.TableReader { + const _UniverseReader(); + + @override + Universe createObject(fb.BufferContext bc, int offset) => + Universe._(bc, offset); +} + +class UniverseBuilder { + UniverseBuilder(this.fbBuilder); + + final fb.Builder fbBuilder; + + void begin() { + fbBuilder.startTable(2); + } + + int addAge(double? age) { + fbBuilder.addFloat64(0, age); + return fbBuilder.offset; + } + int addGalaxiesOffset(int? offset) { + fbBuilder.addOffset(1, offset); + return fbBuilder.offset; + } + + int finish() { + return fbBuilder.endTable(); + } +} + +class UniverseObjectBuilder extends fb.ObjectBuilder { + final double? _age; + final List? _galaxies; + + UniverseObjectBuilder({ + double? age, + List? galaxies, + }) + : _age = age, + _galaxies = galaxies; + + /// Finish building, and store into the [fbBuilder]. + @override + int finish(fb.Builder fbBuilder) { + final int? galaxiesOffset = _galaxies == null ? null + : fbBuilder.writeList(_galaxies!.map((b) => b.getOrCreateOffset(fbBuilder)).toList()); + fbBuilder.startTable(2); + fbBuilder.addFloat64(0, _age); + fbBuilder.addOffset(1, galaxiesOffset); + return fbBuilder.endTable(); + } + + /// Convenience method to serialize to byte list. + @override + Uint8List toBytes([String? fileIdentifier]) { + final fbBuilder = fb.Builder(deduplicateTables: false); + fbBuilder.finish(finish(fbBuilder), fileIdentifier); + return fbBuilder.buffer; + } +} diff --git a/goldens/dart/generate.py b/goldens/dart/generate.py new file mode 100644 index 000000000..a92070c26 --- /dev/null +++ b/goldens/dart/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Dart specifics + flatc_golden(options=["--dart"] + options, schema=schema, prefix="dart") + + +def GenerateDart(): + flatc([], "basic.fbs") diff --git a/goldens/generate_goldens.py b/goldens/generate_goldens.py index 22fdd4e85..756a604cb 100755 --- a/goldens/generate_goldens.py +++ b/goldens/generate_goldens.py @@ -2,9 +2,32 @@ from cpp.generate import GenerateCpp from csharp.generate import GenerateCSharp +from dart.generate import GenerateDart +from go.generate import GenerateGo +from java.generate import GenerateJava +from kotlin.generate import GenerateKotlin +from lobster.generate import GenerateLobster +from lua.generate import GenerateLua +from nim.generate import GenerateNim +from php.generate import GeneratePhp +from py.generate import GeneratePython +from rust.generate import GenerateRust +from swift.generate import GenerateSwift +from ts.generate import GenerateTs # Run each language generation logic GenerateCpp() GenerateCSharp() - -# TODO add other languages \ No newline at end of file +GenerateDart() +GenerateGo() +GenerateJava() +GenerateKotlin() +GenerateLobster() +# TODO this doesn't respect the output prefix, fix and reenable +#GenerateLua() +GenerateNim() +GeneratePhp() +GeneratePython() +GenerateRust() +GenerateSwift() +GenerateTs() diff --git a/goldens/go/Galaxy.go b/goldens/go/Galaxy.go new file mode 100644 index 000000000..870490518 --- /dev/null +++ b/goldens/go/Galaxy.go @@ -0,0 +1,64 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Galaxy + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Galaxy struct { + _tab flatbuffers.Table +} + +func GetRootAsGalaxy(buf []byte, offset flatbuffers.UOffsetT) *Galaxy { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Galaxy{} + x.Init(buf, n+offset) + return x +} + +func FinishGalaxyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsGalaxy(buf []byte, offset flatbuffers.UOffsetT) *Galaxy { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Galaxy{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedGalaxyBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Galaxy) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Galaxy) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Galaxy) NumStars() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *Galaxy) MutateNumStars(n int64) bool { + return rcv._tab.MutateInt64Slot(4, n) +} + +func GalaxyStart(builder *flatbuffers.Builder) { + builder.StartObject(1) +} +func GalaxyAddNumStars(builder *flatbuffers.Builder, numStars int64) { + builder.PrependInt64Slot(0, numStars, 0) +} +func GalaxyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/goldens/go/Universe.go b/goldens/go/Universe.go new file mode 100644 index 000000000..0f07f1693 --- /dev/null +++ b/goldens/go/Universe.go @@ -0,0 +1,90 @@ +// Code generated by the FlatBuffers compiler. DO NOT EDIT. + +package Universe + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type Universe struct { + _tab flatbuffers.Table +} + +func GetRootAsUniverse(buf []byte, offset flatbuffers.UOffsetT) *Universe { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &Universe{} + x.Init(buf, n+offset) + return x +} + +func FinishUniverseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.Finish(offset) +} + +func GetSizePrefixedRootAsUniverse(buf []byte, offset flatbuffers.UOffsetT) *Universe { + n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:]) + x := &Universe{} + x.Init(buf, n+offset+flatbuffers.SizeUint32) + return x +} + +func FinishSizePrefixedUniverseBuffer(builder *flatbuffers.Builder, offset flatbuffers.UOffsetT) { + builder.FinishSizePrefixed(offset) +} + +func (rcv *Universe) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *Universe) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *Universe) Age() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *Universe) MutateAge(n float64) bool { + return rcv._tab.MutateFloat64Slot(4, n) +} + +func (rcv *Universe) Galaxies(obj *Galaxy, j int) bool { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + x := rcv._tab.Vector(o) + x += flatbuffers.UOffsetT(j) * 4 + x = rcv._tab.Indirect(x) + obj.Init(rcv._tab.Bytes, x) + return true + } + return false +} + +func (rcv *Universe) GalaxiesLength() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func UniverseStart(builder *flatbuffers.Builder) { + builder.StartObject(2) +} +func UniverseAddAge(builder *flatbuffers.Builder, age float64) { + builder.PrependFloat64Slot(0, age, 0.0) +} +func UniverseAddGalaxies(builder *flatbuffers.Builder, galaxies flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(galaxies), 0) +} +func UniverseStartGalaxiesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(4, numElems, 4) +} +func UniverseEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/goldens/go/generate.py b/goldens/go/generate.py new file mode 100644 index 000000000..358c42c30 --- /dev/null +++ b/goldens/go/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Go specifics + flatc_golden(options=["--go"] + options, schema=schema, prefix="go") + + +def GenerateGo(): + flatc([], "basic.fbs") diff --git a/goldens/java/Galaxy.java b/goldens/java/Galaxy.java new file mode 100644 index 000000000..d18124b73 --- /dev/null +++ b/goldens/java/Galaxy.java @@ -0,0 +1,51 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +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 Galaxy extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); } + public static Galaxy getRootAsGalaxy(ByteBuffer _bb) { return getRootAsGalaxy(_bb, new Galaxy()); } + public static Galaxy getRootAsGalaxy(ByteBuffer _bb, Galaxy obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public Galaxy __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public long numStars() { int o = __offset(4); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } + + public static int createGalaxy(FlatBufferBuilder builder, + long numStars) { + builder.startTable(1); + Galaxy.addNumStars(builder, numStars); + return Galaxy.endGalaxy(builder); + } + + public static void startGalaxy(FlatBufferBuilder builder) { builder.startTable(1); } + public static void addNumStars(FlatBufferBuilder builder, long numStars) { builder.addLong(0, numStars, 0L); } + public static int endGalaxy(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + + 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 Galaxy get(int j) { return get(new Galaxy(), j); } + public Galaxy get(Galaxy obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } +} + diff --git a/goldens/java/Universe.java b/goldens/java/Universe.java new file mode 100644 index 000000000..b02bdc390 --- /dev/null +++ b/goldens/java/Universe.java @@ -0,0 +1,63 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +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 Universe extends Table { + public static void ValidateVersion() { Constants.FLATBUFFERS_23_3_3(); } + public static Universe getRootAsUniverse(ByteBuffer _bb) { return getRootAsUniverse(_bb, new Universe()); } + public static Universe getRootAsUniverse(ByteBuffer _bb, Universe obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); } + public Universe __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public double age() { int o = __offset(4); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; } + public Galaxy galaxies(int j) { return galaxies(new Galaxy(), j); } + public Galaxy galaxies(Galaxy obj, int j) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; } + public int galaxiesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; } + public Galaxy.Vector galaxiesVector() { return galaxiesVector(new Galaxy.Vector()); } + public Galaxy.Vector galaxiesVector(Galaxy.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; } + + public static int createUniverse(FlatBufferBuilder builder, + double age, + int galaxiesOffset) { + builder.startTable(2); + Universe.addAge(builder, age); + Universe.addGalaxies(builder, galaxiesOffset); + return Universe.endUniverse(builder); + } + + public static void startUniverse(FlatBufferBuilder builder) { builder.startTable(2); } + public static void addAge(FlatBufferBuilder builder, double age) { builder.addDouble(0, age, 0.0); } + public static void addGalaxies(FlatBufferBuilder builder, int galaxiesOffset) { builder.addOffset(1, galaxiesOffset, 0); } + public static int createGalaxiesVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); } + public static void startGalaxiesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); } + public static int endUniverse(FlatBufferBuilder builder) { + int o = builder.endTable(); + return o; + } + public static void finishUniverseBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset); } + public static void finishSizePrefixedUniverseBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset); } + + 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 Universe get(int j) { return get(new Universe(), j); } + public Universe get(Universe obj, int j) { return obj.__assign(__indirect(__element(j), bb), bb); } + } +} + diff --git a/goldens/java/generate.py b/goldens/java/generate.py new file mode 100644 index 000000000..cc1a8b294 --- /dev/null +++ b/goldens/java/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Java specifics + flatc_golden(options=["--java"] + options, schema=schema, prefix="java") + + +def GenerateJava(): + flatc([], "basic.fbs") diff --git a/goldens/kotlin/Galaxy.kt b/goldens/kotlin/Galaxy.kt new file mode 100644 index 000000000..891858ae1 --- /dev/null +++ b/goldens/kotlin/Galaxy.kt @@ -0,0 +1,53 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +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 Galaxy : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : Galaxy { + __init(_i, _bb) + return this + } + val numStars : Long + get() { + val o = __offset(4) + return if(o != 0) bb.getLong(o + bb_pos) else 0L + } + companion object { + fun validateVersion() = Constants.FLATBUFFERS_23_3_3() + fun getRootAsGalaxy(_bb: ByteBuffer): Galaxy = getRootAsGalaxy(_bb, Galaxy()) + fun getRootAsGalaxy(_bb: ByteBuffer, obj: Galaxy): Galaxy { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + fun createGalaxy(builder: FlatBufferBuilder, numStars: Long) : Int { + builder.startTable(1) + addNumStars(builder, numStars) + return endGalaxy(builder) + } + fun startGalaxy(builder: FlatBufferBuilder) = builder.startTable(1) + fun addNumStars(builder: FlatBufferBuilder, numStars: Long) = builder.addLong(0, numStars, 0L) + fun endGalaxy(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + } +} diff --git a/goldens/kotlin/Universe.kt b/goldens/kotlin/Universe.kt new file mode 100644 index 000000000..494430448 --- /dev/null +++ b/goldens/kotlin/Universe.kt @@ -0,0 +1,78 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +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 Universe : Table() { + + fun __init(_i: Int, _bb: ByteBuffer) { + __reset(_i, _bb) + } + fun __assign(_i: Int, _bb: ByteBuffer) : Universe { + __init(_i, _bb) + return this + } + val age : Double + get() { + val o = __offset(4) + return if(o != 0) bb.getDouble(o + bb_pos) else 0.0 + } + fun galaxies(j: Int) : Galaxy? = galaxies(Galaxy(), j) + fun galaxies(obj: Galaxy, j: Int) : Galaxy? { + val o = __offset(6) + return if (o != 0) { + obj.__assign(__indirect(__vector(o) + j * 4), bb) + } else { + null + } + } + val galaxiesLength : Int + get() { + val o = __offset(6); return if (o != 0) __vector_len(o) else 0 + } + companion object { + fun validateVersion() = Constants.FLATBUFFERS_23_3_3() + fun getRootAsUniverse(_bb: ByteBuffer): Universe = getRootAsUniverse(_bb, Universe()) + fun getRootAsUniverse(_bb: ByteBuffer, obj: Universe): Universe { + _bb.order(ByteOrder.LITTLE_ENDIAN) + return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)) + } + fun createUniverse(builder: FlatBufferBuilder, age: Double, galaxiesOffset: Int) : Int { + builder.startTable(2) + addAge(builder, age) + addGalaxies(builder, galaxiesOffset) + return endUniverse(builder) + } + fun startUniverse(builder: FlatBufferBuilder) = builder.startTable(2) + fun addAge(builder: FlatBufferBuilder, age: Double) = builder.addDouble(0, age, 0.0) + fun addGalaxies(builder: FlatBufferBuilder, galaxies: Int) = builder.addOffset(1, galaxies, 0) + fun createGalaxiesVector(builder: FlatBufferBuilder, data: IntArray) : Int { + builder.startVector(4, data.size, 4) + for (i in data.size - 1 downTo 0) { + builder.addOffset(data[i]) + } + return builder.endVector() + } + fun startGalaxiesVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(4, numElems, 4) + fun endUniverse(builder: FlatBufferBuilder) : Int { + val o = builder.endTable() + return o + } + fun finishUniverseBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finish(offset) + fun finishSizePrefixedUniverseBuffer(builder: FlatBufferBuilder, offset: Int) = builder.finishSizePrefixed(offset) + } +} diff --git a/goldens/kotlin/generate.py b/goldens/kotlin/generate.py new file mode 100644 index 000000000..ac8b55174 --- /dev/null +++ b/goldens/kotlin/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Kotlin specifics + flatc_golden(options=["--kotlin"] + options, schema=schema, prefix="kotlin") + + +def GenerateKotlin(): + flatc([], "basic.fbs") diff --git a/goldens/lobster/basic_generated.lobster b/goldens/lobster/basic_generated.lobster new file mode 100644 index 000000000..5d4fd25b8 --- /dev/null +++ b/goldens/lobster/basic_generated.lobster @@ -0,0 +1,55 @@ +// automatically generated by the FlatBuffers compiler, do not modify +import flatbuffers + +class Galaxy + +class Universe + +class Galaxy : flatbuffers_handle + def num_stars() -> int: + return buf_.flatbuffers_field_int64(pos_, 4, 0) + +def GetRootAsGalaxy(buf:string): return Galaxy { buf, buf.flatbuffers_indirect(0) } + +struct GalaxyBuilder: + b_:flatbuffers_builder + def start(): + b_.StartObject(1) + return this + def add_num_stars(num_stars:int): + b_.PrependInt64Slot(0, num_stars, 0) + return this + def end(): + return b_.EndObject() + +class Universe : flatbuffers_handle + def age() -> float: + return buf_.flatbuffers_field_float64(pos_, 4, 0.0) + def galaxies(i:int) -> Galaxy: + return Galaxy { buf_, buf_.flatbuffers_indirect(buf_.flatbuffers_field_vector(pos_, 6) + i * 4) } + def galaxies_length() -> int: + return buf_.flatbuffers_field_vector_len(pos_, 6) + +def GetRootAsUniverse(buf:string): return Universe { buf, buf.flatbuffers_indirect(0) } + +struct UniverseBuilder: + b_:flatbuffers_builder + def start(): + b_.StartObject(2) + return this + def add_age(age:float): + b_.PrependFloat64Slot(0, age, 0.0) + return this + def add_galaxies(galaxies:flatbuffers_offset): + b_.PrependUOffsetTRelativeSlot(1, galaxies) + return this + def end(): + return b_.EndObject() + +def UniverseStartGalaxiesVector(b_:flatbuffers_builder, n_:int): + b_.StartVector(4, n_, 4) +def UniverseCreateGalaxiesVector(b_:flatbuffers_builder, v_:[flatbuffers_offset]): + b_.StartVector(4, v_.length, 4) + reverse(v_) e_: b_.PrependUOffsetTRelative(e_) + return b_.EndVector(v_.length) + diff --git a/goldens/lobster/generate.py b/goldens/lobster/generate.py new file mode 100644 index 000000000..cb75fda4b --- /dev/null +++ b/goldens/lobster/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Lobster specifics + flatc_golden(options=["--lobster"] + options, schema=schema, prefix="lobster") + + +def GenerateLobster(): + flatc([], "basic.fbs") diff --git a/goldens/lua/generate.py b/goldens/lua/generate.py new file mode 100644 index 000000000..d099118a8 --- /dev/null +++ b/goldens/lua/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Lua specifics + flatc_golden(options=["--lua"] + options, schema=schema, prefix="lua") + + +def GenerateLua(): + flatc([], "basic.fbs") diff --git a/goldens/nim/generate.py b/goldens/nim/generate.py new file mode 100644 index 000000000..16c0d3bcd --- /dev/null +++ b/goldens/nim/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Nim specifics + flatc_golden(options=["--nim"] + options, schema=schema, prefix="nim") + + +def GenerateNim(): + flatc([], "basic.fbs") diff --git a/goldens/php/Galaxy.php b/goldens/php/Galaxy.php new file mode 100644 index 000000000..256a72e4b --- /dev/null +++ b/goldens/php/Galaxy.php @@ -0,0 +1,82 @@ +init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb)); + } + + /** + * @param int $_i offset + * @param ByteBuffer $_bb + * @return Galaxy + **/ + public function init($_i, ByteBuffer $_bb) + { + $this->bb_pos = $_i; + $this->bb = $_bb; + return $this; + } + + /** + * @return long + */ + public function getNumStars() + { + $o = $this->__offset(4); + return $o != 0 ? $this->bb->getLong($o + $this->bb_pos) : 0; + } + + /** + * @param FlatBufferBuilder $builder + * @return void + */ + public static function startGalaxy(FlatBufferBuilder $builder) + { + $builder->StartObject(1); + } + + /** + * @param FlatBufferBuilder $builder + * @return Galaxy + */ + public static function createGalaxy(FlatBufferBuilder $builder, $num_stars) + { + $builder->startObject(1); + self::addNumStars($builder, $num_stars); + $o = $builder->endObject(); + return $o; + } + + /** + * @param FlatBufferBuilder $builder + * @param long + * @return void + */ + public static function addNumStars(FlatBufferBuilder $builder, $numStars) + { + $builder->addLongX(0, $numStars, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @return int table offset + */ + public static function endGalaxy(FlatBufferBuilder $builder) + { + $o = $builder->endObject(); + return $o; + } +} diff --git a/goldens/php/Universe.php b/goldens/php/Universe.php new file mode 100644 index 000000000..ea98096b6 --- /dev/null +++ b/goldens/php/Universe.php @@ -0,0 +1,141 @@ +init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb)); + } + + /** + * @param int $_i offset + * @param ByteBuffer $_bb + * @return Universe + **/ + public function init($_i, ByteBuffer $_bb) + { + $this->bb_pos = $_i; + $this->bb = $_bb; + return $this; + } + + /** + * @return double + */ + public function getAge() + { + $o = $this->__offset(4); + return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : 0.0; + } + + /** + * @returnVectorOffset + */ + public function getGalaxies($j) + { + $o = $this->__offset(6); + $obj = new Galaxy(); + return $o != 0 ? $obj->init($this->__indirect($this->__vector($o) + $j * 4), $this->bb) : null; + } + + /** + * @return int + */ + public function getGalaxiesLength() + { + $o = $this->__offset(6); + return $o != 0 ? $this->__vector_len($o) : 0; + } + + /** + * @param FlatBufferBuilder $builder + * @return void + */ + public static function startUniverse(FlatBufferBuilder $builder) + { + $builder->StartObject(2); + } + + /** + * @param FlatBufferBuilder $builder + * @return Universe + */ + public static function createUniverse(FlatBufferBuilder $builder, $age, $galaxies) + { + $builder->startObject(2); + self::addAge($builder, $age); + self::addGalaxies($builder, $galaxies); + $o = $builder->endObject(); + return $o; + } + + /** + * @param FlatBufferBuilder $builder + * @param double + * @return void + */ + public static function addAge(FlatBufferBuilder $builder, $age) + { + $builder->addDoubleX(0, $age, 0.0); + } + + /** + * @param FlatBufferBuilder $builder + * @param VectorOffset + * @return void + */ + public static function addGalaxies(FlatBufferBuilder $builder, $galaxies) + { + $builder->addOffsetX(1, $galaxies, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param array offset array + * @return int vector offset + */ + public static function createGalaxiesVector(FlatBufferBuilder $builder, array $data) + { + $builder->startVector(4, count($data), 4); + for ($i = count($data) - 1; $i >= 0; $i--) { + $builder->putOffset($data[$i]); + } + return $builder->endVector(); + } + + /** + * @param FlatBufferBuilder $builder + * @param int $numElems + * @return void + */ + public static function startGalaxiesVector(FlatBufferBuilder $builder, $numElems) + { + $builder->startVector(4, $numElems, 4); + } + + /** + * @param FlatBufferBuilder $builder + * @return int table offset + */ + public static function endUniverse(FlatBufferBuilder $builder) + { + $o = $builder->endObject(); + return $o; + } + + public static function finishUniverseBuffer(FlatBufferBuilder $builder, $offset) + { + $builder->finish($offset); + } +} diff --git a/goldens/php/generate.py b/goldens/php/generate.py new file mode 100644 index 000000000..6e9144c67 --- /dev/null +++ b/goldens/php/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with PHP specifics + flatc_golden(options=["--php"] + options, schema=schema, prefix="php") + + +def GeneratePhp(): + flatc([], "basic.fbs") diff --git a/goldens/py/Galaxy.py b/goldens/py/Galaxy.py new file mode 100644 index 000000000..4b28f68a9 --- /dev/null +++ b/goldens/py/Galaxy.py @@ -0,0 +1,50 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Galaxy(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Galaxy() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsGalaxy(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + # Galaxy + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Galaxy + def NumStars(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + +def GalaxyStart(builder): + builder.StartObject(1) + +def Start(builder): + GalaxyStart(builder) + +def GalaxyAddNumStars(builder, numStars): + builder.PrependInt64Slot(0, numStars, 0) + +def AddNumStars(builder: flatbuffers.Builder, numStars: int): + GalaxyAddNumStars(builder, numStars) + +def GalaxyEnd(builder): + return builder.EndObject() + +def End(builder): + return GalaxyEnd(builder) diff --git a/goldens/py/Universe.py b/goldens/py/Universe.py new file mode 100644 index 000000000..fa0044c50 --- /dev/null +++ b/goldens/py/Universe.py @@ -0,0 +1,87 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: + +import flatbuffers +from flatbuffers.compat import import_numpy +np = import_numpy() + +class Universe(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAs(cls, buf, offset=0): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Universe() + x.Init(buf, n + offset) + return x + + @classmethod + def GetRootAsUniverse(cls, buf, offset=0): + """This method is deprecated. Please switch to GetRootAs.""" + return cls.GetRootAs(buf, offset) + # Universe + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Universe + def Age(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) + return 0.0 + + # Universe + def Galaxies(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from .Galaxy import Galaxy + obj = Galaxy() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # Universe + def GalaxiesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Universe + def GalaxiesIsNone(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + return o == 0 + +def UniverseStart(builder): + builder.StartObject(2) + +def Start(builder): + UniverseStart(builder) + +def UniverseAddAge(builder, age): + builder.PrependFloat64Slot(0, age, 0.0) + +def AddAge(builder: flatbuffers.Builder, age: float): + UniverseAddAge(builder, age) + +def UniverseAddGalaxies(builder, galaxies): + builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(galaxies), 0) + +def AddGalaxies(builder: flatbuffers.Builder, galaxies: int): + UniverseAddGalaxies(builder, galaxies) + +def UniverseStartGalaxiesVector(builder, numElems): + return builder.StartVector(4, numElems, 4) + +def StartGalaxiesVector(builder, numElems: int) -> int: + return UniverseStartGalaxiesVector(builder, numElems) + +def UniverseEnd(builder): + return builder.EndObject() + +def End(builder): + return UniverseEnd(builder) diff --git a/goldens/py/__init__.py b/goldens/py/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/goldens/py/generate.py b/goldens/py/generate.py new file mode 100644 index 000000000..ceff5d2d6 --- /dev/null +++ b/goldens/py/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Python specifics + flatc_golden(options=["--python"] + options, schema=schema, prefix="py") + + +def GeneratePython(): + flatc([], "basic.fbs") diff --git a/goldens/rust/basic_generated.rs b/goldens/rust/basic_generated.rs new file mode 100644 index 000000000..f755a5fe7 --- /dev/null +++ b/goldens/rust/basic_generated.rs @@ -0,0 +1,293 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +// @generated + +use core::mem; +use core::cmp::Ordering; + +extern crate flatbuffers; +use self::flatbuffers::{EndianScalar, Follow}; + +pub enum GalaxyOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct Galaxy<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for Galaxy<'a> { + type Inner = Galaxy<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> Galaxy<'a> { + pub const VT_NUM_STARS: flatbuffers::VOffsetT = 4; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + Galaxy { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args GalaxyArgs + ) -> flatbuffers::WIPOffset> { + let mut builder = GalaxyBuilder::new(_fbb); + builder.add_num_stars(args.num_stars); + builder.finish() + } + + + #[inline] + pub fn num_stars(&self) -> i64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Galaxy::VT_NUM_STARS, Some(0)).unwrap()} + } +} + +impl flatbuffers::Verifiable for Galaxy<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("num_stars", Self::VT_NUM_STARS, false)? + .finish(); + Ok(()) + } +} +pub struct GalaxyArgs { + pub num_stars: i64, +} +impl<'a> Default for GalaxyArgs { + #[inline] + fn default() -> Self { + GalaxyArgs { + num_stars: 0, + } + } +} + +pub struct GalaxyBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> GalaxyBuilder<'a, 'b> { + #[inline] + pub fn add_num_stars(&mut self, num_stars: i64) { + self.fbb_.push_slot::(Galaxy::VT_NUM_STARS, num_stars, 0); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> GalaxyBuilder<'a, 'b> { + let start = _fbb.start_table(); + GalaxyBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for Galaxy<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("Galaxy"); + ds.field("num_stars", &self.num_stars()); + ds.finish() + } +} +pub enum UniverseOffset {} +#[derive(Copy, Clone, PartialEq)] + +pub struct Universe<'a> { + pub _tab: flatbuffers::Table<'a>, +} + +impl<'a> flatbuffers::Follow<'a> for Universe<'a> { + type Inner = Universe<'a>; + #[inline] + unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner { + Self { _tab: flatbuffers::Table::new(buf, loc) } + } +} + +impl<'a> Universe<'a> { + pub const VT_AGE: flatbuffers::VOffsetT = 4; + pub const VT_GALAXIES: flatbuffers::VOffsetT = 6; + + #[inline] + pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self { + Universe { _tab: table } + } + #[allow(unused_mut)] + pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>( + _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>, + args: &'args UniverseArgs<'args> + ) -> flatbuffers::WIPOffset> { + let mut builder = UniverseBuilder::new(_fbb); + builder.add_age(args.age); + if let Some(x) = args.galaxies { builder.add_galaxies(x); } + builder.finish() + } + + + #[inline] + pub fn age(&self) -> f64 { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::(Universe::VT_AGE, Some(0.0)).unwrap()} + } + #[inline] + pub fn galaxies(&self) -> Option>>> { + // Safety: + // Created from valid Table for this object + // which contains a valid value in this slot + unsafe { self._tab.get::>>>(Universe::VT_GALAXIES, None)} + } +} + +impl flatbuffers::Verifiable for Universe<'_> { + #[inline] + fn run_verifier( + v: &mut flatbuffers::Verifier, pos: usize + ) -> Result<(), flatbuffers::InvalidFlatbuffer> { + use self::flatbuffers::Verifiable; + v.visit_table(pos)? + .visit_field::("age", Self::VT_AGE, false)? + .visit_field::>>>("galaxies", Self::VT_GALAXIES, false)? + .finish(); + Ok(()) + } +} +pub struct UniverseArgs<'a> { + pub age: f64, + pub galaxies: Option>>>>, +} +impl<'a> Default for UniverseArgs<'a> { + #[inline] + fn default() -> Self { + UniverseArgs { + age: 0.0, + galaxies: None, + } + } +} + +pub struct UniverseBuilder<'a: 'b, 'b> { + fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>, + start_: flatbuffers::WIPOffset, +} +impl<'a: 'b, 'b> UniverseBuilder<'a, 'b> { + #[inline] + pub fn add_age(&mut self, age: f64) { + self.fbb_.push_slot::(Universe::VT_AGE, age, 0.0); + } + #[inline] + pub fn add_galaxies(&mut self, galaxies: flatbuffers::WIPOffset>>>) { + self.fbb_.push_slot_always::>(Universe::VT_GALAXIES, galaxies); + } + #[inline] + pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> UniverseBuilder<'a, 'b> { + let start = _fbb.start_table(); + UniverseBuilder { + fbb_: _fbb, + start_: start, + } + } + #[inline] + pub fn finish(self) -> flatbuffers::WIPOffset> { + let o = self.fbb_.end_table(self.start_); + flatbuffers::WIPOffset::new(o.value()) + } +} + +impl core::fmt::Debug for Universe<'_> { + fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result { + let mut ds = f.debug_struct("Universe"); + ds.field("age", &self.age()); + ds.field("galaxies", &self.galaxies()); + ds.finish() + } +} +#[inline] +/// Verifies that a buffer of bytes contains a `Universe` +/// and returns it. +/// Note that verification is still experimental and may not +/// catch every error, or be maximally performant. For the +/// previous, unchecked, behavior use +/// `root_as_universe_unchecked`. +pub fn root_as_universe(buf: &[u8]) -> Result { + flatbuffers::root::(buf) +} +#[inline] +/// Verifies that a buffer of bytes contains a size prefixed +/// `Universe` and returns it. +/// Note that verification is still experimental and may not +/// catch every error, or be maximally performant. For the +/// previous, unchecked, behavior use +/// `size_prefixed_root_as_universe_unchecked`. +pub fn size_prefixed_root_as_universe(buf: &[u8]) -> Result { + flatbuffers::size_prefixed_root::(buf) +} +#[inline] +/// Verifies, with the given options, that a buffer of bytes +/// contains a `Universe` and returns it. +/// Note that verification is still experimental and may not +/// catch every error, or be maximally performant. For the +/// previous, unchecked, behavior use +/// `root_as_universe_unchecked`. +pub fn root_as_universe_with_opts<'b, 'o>( + opts: &'o flatbuffers::VerifierOptions, + buf: &'b [u8], +) -> Result, flatbuffers::InvalidFlatbuffer> { + flatbuffers::root_with_opts::>(opts, buf) +} +#[inline] +/// Verifies, with the given verifier options, that a buffer of +/// bytes contains a size prefixed `Universe` and returns +/// it. Note that verification is still experimental and may not +/// catch every error, or be maximally performant. For the +/// previous, unchecked, behavior use +/// `root_as_universe_unchecked`. +pub fn size_prefixed_root_as_universe_with_opts<'b, 'o>( + opts: &'o flatbuffers::VerifierOptions, + buf: &'b [u8], +) -> Result, flatbuffers::InvalidFlatbuffer> { + flatbuffers::size_prefixed_root_with_opts::>(opts, buf) +} +#[inline] +/// Assumes, without verification, that a buffer of bytes contains a Universe and returns it. +/// # Safety +/// Callers must trust the given bytes do indeed contain a valid `Universe`. +pub unsafe fn root_as_universe_unchecked(buf: &[u8]) -> Universe { + flatbuffers::root_unchecked::(buf) +} +#[inline] +/// Assumes, without verification, that a buffer of bytes contains a size prefixed Universe and returns it. +/// # Safety +/// Callers must trust the given bytes do indeed contain a valid size prefixed `Universe`. +pub unsafe fn size_prefixed_root_as_universe_unchecked(buf: &[u8]) -> Universe { + flatbuffers::size_prefixed_root_unchecked::(buf) +} +#[inline] +pub fn finish_universe_buffer<'a, 'b>( + fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, + root: flatbuffers::WIPOffset>) { + fbb.finish(root, None); +} + +#[inline] +pub fn finish_size_prefixed_universe_buffer<'a, 'b>(fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>, root: flatbuffers::WIPOffset>) { + fbb.finish_size_prefixed(root, None); +} diff --git a/goldens/rust/generate.py b/goldens/rust/generate.py new file mode 100644 index 000000000..f3a568fef --- /dev/null +++ b/goldens/rust/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Rust specifics + flatc_golden(options=["--rust"] + options, schema=schema, prefix="rust") + + +def GenerateRust(): + flatc([], "basic.fbs") diff --git a/goldens/swift/basic_generated.swift b/goldens/swift/basic_generated.swift new file mode 100644 index 000000000..70e5a2335 --- /dev/null +++ b/goldens/swift/basic_generated.swift @@ -0,0 +1,84 @@ +// automatically generated by the FlatBuffers compiler, do not modify +// swiftlint:disable all +// swiftformat:disable all + +import FlatBuffers + +public struct Galaxy: FlatBufferObject, Verifiable { + + static func validateVersion() { FlatBuffersVersion_23_3_3() } + public var __buffer: ByteBuffer! { return _accessor.bb } + private var _accessor: Table + + private init(_ t: Table) { _accessor = t } + public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) } + + private enum VTOFFSET: VOffset { + case numStars = 4 + var v: Int32 { Int32(self.rawValue) } + var p: VOffset { self.rawValue } + } + + public var numStars: Int64 { let o = _accessor.offset(VTOFFSET.numStars.v); return o == 0 ? 0 : _accessor.readBuffer(of: Int64.self, at: o) } + public static func startGalaxy(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 1) } + public static func add(numStars: Int64, _ fbb: inout FlatBufferBuilder) { fbb.add(element: numStars, def: 0, at: VTOFFSET.numStars.p) } + public static func endGalaxy(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end } + public static func createGalaxy( + _ fbb: inout FlatBufferBuilder, + numStars: Int64 = 0 + ) -> Offset { + let __start = Galaxy.startGalaxy(&fbb) + Galaxy.add(numStars: numStars, &fbb) + return Galaxy.endGalaxy(&fbb, start: __start) + } + + public static func verify(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable { + var _v = try verifier.visitTable(at: position) + try _v.visit(field: VTOFFSET.numStars.p, fieldName: "numStars", required: false, type: Int64.self) + _v.finish() + } +} + +public struct Universe: FlatBufferObject, Verifiable { + + static func validateVersion() { FlatBuffersVersion_23_3_3() } + public var __buffer: ByteBuffer! { return _accessor.bb } + private var _accessor: Table + + private init(_ t: Table) { _accessor = t } + public init(_ bb: ByteBuffer, o: Int32) { _accessor = Table(bb: bb, position: o) } + + private enum VTOFFSET: VOffset { + case age = 4 + case galaxies = 6 + var v: Int32 { Int32(self.rawValue) } + var p: VOffset { self.rawValue } + } + + public var age: Double { let o = _accessor.offset(VTOFFSET.age.v); return o == 0 ? 0.0 : _accessor.readBuffer(of: Double.self, at: o) } + public var hasGalaxies: Bool { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? false : true } + public var galaxiesCount: Int32 { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? 0 : _accessor.vector(count: o) } + public func galaxies(at index: Int32) -> Galaxy? { let o = _accessor.offset(VTOFFSET.galaxies.v); return o == 0 ? nil : Galaxy(_accessor.bb, o: _accessor.indirect(_accessor.vector(at: o) + index * 4)) } + public static func startUniverse(_ fbb: inout FlatBufferBuilder) -> UOffset { fbb.startTable(with: 2) } + public static func add(age: Double, _ fbb: inout FlatBufferBuilder) { fbb.add(element: age, def: 0.0, at: VTOFFSET.age.p) } + public static func addVectorOf(galaxies: Offset, _ fbb: inout FlatBufferBuilder) { fbb.add(offset: galaxies, at: VTOFFSET.galaxies.p) } + public static func endUniverse(_ fbb: inout FlatBufferBuilder, start: UOffset) -> Offset { let end = Offset(offset: fbb.endTable(at: start)); return end } + public static func createUniverse( + _ fbb: inout FlatBufferBuilder, + age: Double = 0.0, + galaxiesVectorOffset galaxies: Offset = Offset() + ) -> Offset { + let __start = Universe.startUniverse(&fbb) + Universe.add(age: age, &fbb) + Universe.addVectorOf(galaxies: galaxies, &fbb) + return Universe.endUniverse(&fbb, start: __start) + } + + public static func verify(_ verifier: inout Verifier, at position: Int, of type: T.Type) throws where T: Verifiable { + var _v = try verifier.visitTable(at: position) + try _v.visit(field: VTOFFSET.age.p, fieldName: "age", required: false, type: Double.self) + try _v.visit(field: VTOFFSET.galaxies.p, fieldName: "galaxies", required: false, type: ForwardOffset, Galaxy>>.self) + _v.finish() + } +} + diff --git a/goldens/swift/generate.py b/goldens/swift/generate.py new file mode 100644 index 000000000..ccdb97e77 --- /dev/null +++ b/goldens/swift/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Swift specifics + flatc_golden(options=["--swift"] + options, schema=schema, prefix="swift") + + +def GenerateSwift(): + flatc([], "basic.fbs") diff --git a/goldens/ts/basic.ts b/goldens/ts/basic.ts new file mode 100644 index 000000000..76af441a9 --- /dev/null +++ b/goldens/ts/basic.ts @@ -0,0 +1,4 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export { Galaxy } from './galaxy.js'; +export { Universe } from './universe.js'; diff --git a/goldens/ts/galaxy.ts b/goldens/ts/galaxy.ts new file mode 100644 index 000000000..8576cbf83 --- /dev/null +++ b/goldens/ts/galaxy.ts @@ -0,0 +1,46 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +export class Galaxy { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):Galaxy { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsGalaxy(bb:flatbuffers.ByteBuffer, obj?:Galaxy):Galaxy { + return (obj || new Galaxy()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsGalaxy(bb:flatbuffers.ByteBuffer, obj?:Galaxy):Galaxy { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new Galaxy()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +numStars():bigint { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0'); +} + +static startGalaxy(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addNumStars(builder:flatbuffers.Builder, numStars:bigint) { + builder.addFieldInt64(0, numStars, BigInt('0')); +} + +static endGalaxy(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createGalaxy(builder:flatbuffers.Builder, numStars:bigint):flatbuffers.Offset { + Galaxy.startGalaxy(builder); + Galaxy.addNumStars(builder, numStars); + return Galaxy.endGalaxy(builder); +} +} diff --git a/goldens/ts/generate.py b/goldens/ts/generate.py new file mode 100644 index 000000000..ee072fdd6 --- /dev/null +++ b/goldens/ts/generate.py @@ -0,0 +1,10 @@ +from golden_utils import flatc_golden + + +def flatc(options, schema): + # Wrap the golden flatc generator with Swift specifics + flatc_golden(options=["--ts"] + options, schema=schema, prefix="ts") + + +def GenerateTs(): + flatc([], "basic.fbs") diff --git a/goldens/ts/universe.ts b/goldens/ts/universe.ts new file mode 100644 index 000000000..2f8c26cff --- /dev/null +++ b/goldens/ts/universe.ts @@ -0,0 +1,84 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { Galaxy } from './galaxy.js'; + + +export class Universe { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):Universe { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsUniverse(bb:flatbuffers.ByteBuffer, obj?:Universe):Universe { + return (obj || new Universe()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsUniverse(bb:flatbuffers.ByteBuffer, obj?:Universe):Universe { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new Universe()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +age():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0; +} + +galaxies(index: number, obj?:Galaxy):Galaxy|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? (obj || new Galaxy()).__init(this.bb!.__indirect(this.bb!.__vector(this.bb_pos + offset) + index * 4), this.bb!) : null; +} + +galaxiesLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +static startUniverse(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addAge(builder:flatbuffers.Builder, age:number) { + builder.addFieldFloat64(0, age, 0.0); +} + +static addGalaxies(builder:flatbuffers.Builder, galaxiesOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, galaxiesOffset, 0); +} + +static createGalaxiesVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset { + builder.startVector(4, data.length, 4); + for (let i = data.length - 1; i >= 0; i--) { + builder.addOffset(data[i]!); + } + return builder.endVector(); +} + +static startGalaxiesVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(4, numElems, 4); +} + +static endUniverse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static finishUniverseBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) { + builder.finish(offset); +} + +static finishSizePrefixedUniverseBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) { + builder.finish(offset, undefined, true); +} + +static createUniverse(builder:flatbuffers.Builder, age:number, galaxiesOffset:flatbuffers.Offset):flatbuffers.Offset { + Universe.startUniverse(builder); + Universe.addAge(builder, age); + Universe.addGalaxies(builder, galaxiesOffset); + return Universe.endUniverse(builder); +} +}