From f2b3705c2c62c40afdef96f73f0aeaf32b4c8e0e Mon Sep 17 00:00:00 2001 From: MikkelFJ Date: Wed, 2 Aug 2017 17:07:43 +0200 Subject: [PATCH] Add scalar type aliases for int8, uint8, ..., f32, f64 (#4400) * Add type aliases * Add generated code * Rebase master --- include/flatbuffers/idl.h | 41 +- src/idl_gen_cpp.cpp | 2 +- src/idl_gen_general.cpp | 6 +- src/idl_gen_go.cpp | 3 +- src/idl_gen_php.cpp | 3 +- src/idl_gen_python.cpp | 3 +- src/idl_gen_text.cpp | 12 +- src/idl_parser.cpp | 29 +- tests/MyGame/Example/TypeAliases.cs | 102 ++++ tests/MyGame/Example/TypeAliases.go | 230 +++++++ tests/MyGame/Example/TypeAliases.java | 97 +++ tests/MyGame/Example/TypeAliases.php | 387 ++++++++++++ tests/MyGame/Example/TypeAliases.py | 150 +++++ tests/monster_test.bfbs | Bin 4064 -> 5328 bytes tests/monster_test.fbs | 15 + tests/monster_test.schema.json | 17 + tests/monster_test_generated.h | 334 +++++++++- tests/monster_test_generated.js | 469 ++++++++++++++ tests/monster_test_generated.ts | 572 +++++++++++++++++- .../namespace_test2_generated.ts | 20 +- tests/test.cpp | 34 ++ 21 files changed, 2461 insertions(+), 65 deletions(-) create mode 100644 tests/MyGame/Example/TypeAliases.cs create mode 100644 tests/MyGame/Example/TypeAliases.go create mode 100644 tests/MyGame/Example/TypeAliases.java create mode 100644 tests/MyGame/Example/TypeAliases.php create mode 100644 tests/MyGame/Example/TypeAliases.py diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index 386c38d4a..cd37b9cc6 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -40,28 +40,29 @@ namespace flatbuffers { // Additionally, Parser::ParseType assumes bool..string is a contiguous range // of type tokens. #define FLATBUFFERS_GEN_TYPES_SCALAR(TD) \ - TD(NONE, "", uint8_t, byte, byte, byte, uint8) \ - TD(UTYPE, "", uint8_t, byte, byte, byte, uint8) /* begin scalar/int */ \ - TD(BOOL, "bool", uint8_t, boolean,byte, bool, bool) \ - TD(CHAR, "byte", int8_t, byte, int8, sbyte, int8) \ - TD(UCHAR, "ubyte", uint8_t, byte, byte, byte, uint8) \ - TD(SHORT, "short", int16_t, short, int16, short, int16) \ - TD(USHORT, "ushort", uint16_t, short, uint16, ushort, uint16) \ - TD(INT, "int", int32_t, int, int32, int, int32) \ - TD(UINT, "uint", uint32_t, int, uint32, uint, uint32) \ - TD(LONG, "long", int64_t, long, int64, long, int64) \ - TD(ULONG, "ulong", uint64_t, long, uint64, ulong, uint64) /* end int */ \ - TD(FLOAT, "float", float, float, float32, float, float32) /* begin float */ \ - TD(DOUBLE, "double", double, double, float64, double, float64) /* end float/scalar */ + TD(NONE, "", "", uint8_t, byte, byte, byte, uint8) \ + TD(UTYPE, "", "", uint8_t, byte, byte, byte, uint8) /* begin scalar/int */ \ + TD(BOOL, "bool", "", uint8_t, boolean,byte, bool, bool) \ + TD(CHAR, "byte", "int8", int8_t, byte, int8, sbyte, int8) \ + TD(UCHAR, "ubyte", "uint8", uint8_t, byte, byte, byte, uint8) \ + TD(SHORT, "short", "int16", int16_t, short, int16, short, int16) \ + TD(USHORT, "ushort", "uint16", uint16_t, short, uint16, ushort, uint16) \ + TD(INT, "int", "int32", int32_t, int, int32, int, int32) \ + TD(UINT, "uint", "uint32", uint32_t, int, uint32, uint, uint32) \ + TD(LONG, "long", "int64", int64_t, long, int64, long, int64) \ + TD(ULONG, "ulong", "uint64", uint64_t, long, uint64, ulong, uint64) /* end int */ \ + TD(FLOAT, "float", "float32", float, float, float32, float, float32) /* begin float */ \ + TD(DOUBLE, "double", "float64", double, double, float64, double, float64) /* end float/scalar */ #define FLATBUFFERS_GEN_TYPES_POINTER(TD) \ - TD(STRING, "string", Offset, int, int, StringOffset, int) \ - TD(VECTOR, "", Offset, int, int, VectorOffset, int) \ - TD(STRUCT, "", Offset, int, int, int, int) \ - TD(UNION, "", Offset, int, int, int, int) + TD(STRING, "string", "", Offset, int, int, StringOffset, int) \ + TD(VECTOR, "", "", Offset, int, int, VectorOffset, int) \ + TD(STRUCT, "", "", Offset, int, int, int, int) \ + TD(UNION, "", "", Offset, int, int, int, int) // The fields are: // - enum // - FlatBuffers schema type. +// - FlatBuffers schema alias type. // - C++ type. // - Java type. // - Go type. @@ -72,7 +73,7 @@ namespace flatbuffers { /* switch (type) { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ // do something specific to CTYPE here FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) @@ -89,13 +90,13 @@ switch (type) { __extension__ // Stop GCC complaining about trailing comma with -Wpendantic. #endif enum BaseType { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ BASE_TYPE_ ## ENUM, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD }; -#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ +#define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ static_assert(sizeof(CTYPE) <= sizeof(largest_scalar_t), \ "define largest_scalar_t as " #CTYPE); FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) diff --git a/src/idl_gen_cpp.cpp b/src/idl_gen_cpp.cpp index 56d10e625..22a6e2228 100644 --- a/src/idl_gen_cpp.cpp +++ b/src/idl_gen_cpp.cpp @@ -302,7 +302,7 @@ class CppGenerator : public BaseGenerator { // Return a C++ type from the table in idl.h std::string GenTypeBasic(const Type &type, bool user_facing_type) const { static const char *ctypename[] = { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #CTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD diff --git a/src/idl_gen_general.cpp b/src/idl_gen_general.cpp index 5c8586d6b..30a097d71 100644 --- a/src/idl_gen_general.cpp +++ b/src/idl_gen_general.cpp @@ -241,14 +241,16 @@ static bool IsEnum(const Type& type) { std::string GenTypeBasic(const Type &type, bool enableLangOverrides) { static const char *java_typename[] = { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #JTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD }; static const char *csharp_typename[] = { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #NTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD diff --git a/src/idl_gen_go.cpp b/src/idl_gen_go.cpp index 4cdbf03c1..8d4a7a595 100644 --- a/src/idl_gen_go.cpp +++ b/src/idl_gen_go.cpp @@ -694,7 +694,8 @@ static std::string GenMethod(const FieldDef &field) { static std::string GenTypeBasic(const Type &type) { static const char *ctypename[] = { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #GTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD diff --git a/src/idl_gen_php.cpp b/src/idl_gen_php.cpp index 7266551f6..8021f92fe 100644 --- a/src/idl_gen_php.cpp +++ b/src/idl_gen_php.cpp @@ -879,7 +879,8 @@ namespace php { static std::string GenTypeBasic(const Type &type) { static const char *ctypename[] = { -#define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ +#define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #NTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD diff --git a/src/idl_gen_python.cpp b/src/idl_gen_python.cpp index 257515b76..acfcf0be2 100644 --- a/src/idl_gen_python.cpp +++ b/src/idl_gen_python.cpp @@ -580,7 +580,8 @@ static std::string GenMethod(const FieldDef &field) { static std::string GenTypeBasic(const Type &type) { static const char *ctypename[] = { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ #PTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD diff --git a/src/idl_gen_text.cpp b/src/idl_gen_text.cpp index e27d664a8..b7c58756c 100644 --- a/src/idl_gen_text.cpp +++ b/src/idl_gen_text.cpp @@ -135,8 +135,8 @@ template<> bool Print(const void *val, type = type.VectorType(); // Call PrintVector above specifically for each element type: switch (type.base_type) { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \ - PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ if (!PrintVector( \ *reinterpret_cast *>(val), \ @@ -226,8 +226,8 @@ static bool GenStruct(const StructDef &struct_def, const Table *table, text += " "; if (is_present) { switch (fd.value.type.base_type) { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \ - PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ if (!GenField(fd, table, struct_def.fixed, \ opts, indent + Indent(opts), _text)) { \ @@ -237,8 +237,8 @@ static bool GenStruct(const StructDef &struct_def, const Table *table, FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD) #undef FLATBUFFERS_TD // Generate drop-thru case statements for all pointer types: - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \ - PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: FLATBUFFERS_GEN_TYPES_POINTER(FLATBUFFERS_TD) #undef FLATBUFFERS_TD diff --git a/src/idl_parser.cpp b/src/idl_parser.cpp index fff35aabe..b8356316b 100644 --- a/src/idl_parser.cpp +++ b/src/idl_parser.cpp @@ -32,7 +32,8 @@ namespace flatbuffers { const char *const kTypeNames[] = { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ IDLTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD @@ -40,7 +41,8 @@ const char *const kTypeNames[] = { }; const char kTypeSizes[] = { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ sizeof(CTYPE), FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD @@ -193,7 +195,8 @@ enum { #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) kToken ## NAME = VALUE, FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) #undef FLATBUFFERS_TOKEN - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ kToken ## ENUM, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD @@ -204,7 +207,8 @@ static std::string TokenToString(int t) { #define FLATBUFFERS_TOKEN(NAME, VALUE, STRING) STRING, FLATBUFFERS_GEN_TOKENS(FLATBUFFERS_TOKEN) #undef FLATBUFFERS_TOKEN - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ IDLTYPE, FLATBUFFERS_GEN_TYPES(FLATBUFFERS_TD) #undef FLATBUFFERS_TD @@ -379,9 +383,9 @@ CheckedError Parser::Next() { cursor_++; attribute_.append(start, cursor_); // First, see if it is a type keyword from the table of types: - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \ - PTYPE) \ - if (attribute_ == IDLTYPE) { \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + if (attribute_ == IDLTYPE || attribute_ == ALIASTYPE) { \ token_ = kToken ## ENUM; \ return NoError(); \ } @@ -1013,8 +1017,8 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, if (!struct_def.sortbysize || size == SizeOf(field_value.type.base_type)) { switch (field_value.type.base_type) { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \ - PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ builder_.Pad(field->padding); \ if (struct_def.fixed) { \ @@ -1030,8 +1034,8 @@ CheckedError Parser::ParseTable(const StructDef &struct_def, std::string *value, break; FLATBUFFERS_GEN_TYPES_SCALAR(FLATBUFFERS_TD); #undef FLATBUFFERS_TD - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, \ - PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ builder_.Pad(field->padding); \ if (IsStruct(field->value.type)) { \ @@ -1107,7 +1111,8 @@ CheckedError Parser::ParseVector(const Type &type, uoffset_t *ovalue) { // start at the back, since we're building the data backwards. auto &val = field_stack_.back().first; switch (val.type.base_type) { - #define FLATBUFFERS_TD(ENUM, IDLTYPE, CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ + #define FLATBUFFERS_TD(ENUM, IDLTYPE, ALIASTYPE, \ + CTYPE, JTYPE, GTYPE, NTYPE, PTYPE) \ case BASE_TYPE_ ## ENUM: \ if (IsStruct(val.type)) SerializeStruct(*val.type.struct_def, val); \ else { \ diff --git a/tests/MyGame/Example/TypeAliases.cs b/tests/MyGame/Example/TypeAliases.cs new file mode 100644 index 000000000..f03c142ba --- /dev/null +++ b/tests/MyGame/Example/TypeAliases.cs @@ -0,0 +1,102 @@ +// +// automatically generated by the FlatBuffers compiler, do not modify +// + +namespace MyGame.Example +{ + +using global::System; +using global::FlatBuffers; + +public struct TypeAliases : IFlatbufferObject +{ + private Table __p; + public ByteBuffer ByteBuffer { get { return __p.bb; } } + public static TypeAliases GetRootAsTypeAliases(ByteBuffer _bb) { return GetRootAsTypeAliases(_bb, new TypeAliases()); } + public static TypeAliases GetRootAsTypeAliases(ByteBuffer _bb, TypeAliases obj) { return (obj.__assign(_bb.GetInt(_bb.Position) + _bb.Position, _bb)); } + public void __init(int _i, ByteBuffer _bb) { __p.bb_pos = _i; __p.bb = _bb; } + public TypeAliases __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public sbyte I8 { get { int o = __p.__offset(4); return o != 0 ? __p.bb.GetSbyte(o + __p.bb_pos) : (sbyte)0; } } + public bool MutateI8(sbyte i8) { int o = __p.__offset(4); if (o != 0) { __p.bb.PutSbyte(o + __p.bb_pos, i8); return true; } else { return false; } } + public byte U8 { get { int o = __p.__offset(6); return o != 0 ? __p.bb.Get(o + __p.bb_pos) : (byte)0; } } + public bool MutateU8(byte u8) { int o = __p.__offset(6); if (o != 0) { __p.bb.Put(o + __p.bb_pos, u8); return true; } else { return false; } } + public short I16 { get { int o = __p.__offset(8); return o != 0 ? __p.bb.GetShort(o + __p.bb_pos) : (short)0; } } + public bool MutateI16(short i16) { int o = __p.__offset(8); if (o != 0) { __p.bb.PutShort(o + __p.bb_pos, i16); return true; } else { return false; } } + public ushort U16 { get { int o = __p.__offset(10); return o != 0 ? __p.bb.GetUshort(o + __p.bb_pos) : (ushort)0; } } + public bool MutateU16(ushort u16) { int o = __p.__offset(10); if (o != 0) { __p.bb.PutUshort(o + __p.bb_pos, u16); return true; } else { return false; } } + public int I32 { get { int o = __p.__offset(12); return o != 0 ? __p.bb.GetInt(o + __p.bb_pos) : (int)0; } } + public bool MutateI32(int i32) { int o = __p.__offset(12); if (o != 0) { __p.bb.PutInt(o + __p.bb_pos, i32); return true; } else { return false; } } + public uint U32 { get { int o = __p.__offset(14); return o != 0 ? __p.bb.GetUint(o + __p.bb_pos) : (uint)0; } } + public bool MutateU32(uint u32) { int o = __p.__offset(14); if (o != 0) { __p.bb.PutUint(o + __p.bb_pos, u32); return true; } else { return false; } } + public long I64 { get { int o = __p.__offset(16); return o != 0 ? __p.bb.GetLong(o + __p.bb_pos) : (long)0; } } + public bool MutateI64(long i64) { int o = __p.__offset(16); if (o != 0) { __p.bb.PutLong(o + __p.bb_pos, i64); return true; } else { return false; } } + public ulong U64 { get { int o = __p.__offset(18); return o != 0 ? __p.bb.GetUlong(o + __p.bb_pos) : (ulong)0; } } + public bool MutateU64(ulong u64) { int o = __p.__offset(18); if (o != 0) { __p.bb.PutUlong(o + __p.bb_pos, u64); return true; } else { return false; } } + public float F32 { get { int o = __p.__offset(20); return o != 0 ? __p.bb.GetFloat(o + __p.bb_pos) : (float)0.0f; } } + public bool MutateF32(float f32) { int o = __p.__offset(20); if (o != 0) { __p.bb.PutFloat(o + __p.bb_pos, f32); return true; } else { return false; } } + public double F64 { get { int o = __p.__offset(22); return o != 0 ? __p.bb.GetDouble(o + __p.bb_pos) : (double)0.0; } } + public bool MutateF64(double f64) { int o = __p.__offset(22); if (o != 0) { __p.bb.PutDouble(o + __p.bb_pos, f64); return true; } else { return false; } } + public sbyte V8(int j) { int o = __p.__offset(24); return o != 0 ? __p.bb.GetSbyte(__p.__vector(o) + j * 1) : (sbyte)0; } + public int V8Length { get { int o = __p.__offset(24); return o != 0 ? __p.__vector_len(o) : 0; } } + public ArraySegment? GetV8Bytes() { return __p.__vector_as_arraysegment(24); } + public bool MutateV8(int j, sbyte v8) { int o = __p.__offset(24); if (o != 0) { __p.bb.PutSbyte(__p.__vector(o) + j * 1, v8); return true; } else { return false; } } + public double Vf64(int j) { int o = __p.__offset(26); return o != 0 ? __p.bb.GetDouble(__p.__vector(o) + j * 8) : (double)0; } + public int Vf64Length { get { int o = __p.__offset(26); return o != 0 ? __p.__vector_len(o) : 0; } } + public ArraySegment? GetVf64Bytes() { return __p.__vector_as_arraysegment(26); } + public bool MutateVf64(int j, double vf64) { int o = __p.__offset(26); if (o != 0) { __p.bb.PutDouble(__p.__vector(o) + j * 8, vf64); return true; } else { return false; } } + + public static Offset CreateTypeAliases(FlatBufferBuilder builder, + sbyte i8 = 0, + byte u8 = 0, + short i16 = 0, + ushort u16 = 0, + int i32 = 0, + uint u32 = 0, + long i64 = 0, + ulong u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + VectorOffset v8Offset = default(VectorOffset), + VectorOffset vf64Offset = default(VectorOffset)) { + builder.StartObject(12); + TypeAliases.AddF64(builder, f64); + TypeAliases.AddU64(builder, u64); + TypeAliases.AddI64(builder, i64); + TypeAliases.AddVf64(builder, vf64Offset); + TypeAliases.AddV8(builder, v8Offset); + TypeAliases.AddF32(builder, f32); + TypeAliases.AddU32(builder, u32); + TypeAliases.AddI32(builder, i32); + TypeAliases.AddU16(builder, u16); + TypeAliases.AddI16(builder, i16); + TypeAliases.AddU8(builder, u8); + TypeAliases.AddI8(builder, i8); + return TypeAliases.EndTypeAliases(builder); + } + + public static void StartTypeAliases(FlatBufferBuilder builder) { builder.StartObject(12); } + public static void AddI8(FlatBufferBuilder builder, sbyte i8) { builder.AddSbyte(0, i8, 0); } + public static void AddU8(FlatBufferBuilder builder, byte u8) { builder.AddByte(1, u8, 0); } + public static void AddI16(FlatBufferBuilder builder, short i16) { builder.AddShort(2, i16, 0); } + public static void AddU16(FlatBufferBuilder builder, ushort u16) { builder.AddUshort(3, u16, 0); } + public static void AddI32(FlatBufferBuilder builder, int i32) { builder.AddInt(4, i32, 0); } + public static void AddU32(FlatBufferBuilder builder, uint u32) { builder.AddUint(5, u32, 0); } + public static void AddI64(FlatBufferBuilder builder, long i64) { builder.AddLong(6, i64, 0); } + public static void AddU64(FlatBufferBuilder builder, ulong u64) { builder.AddUlong(7, u64, 0); } + public static void AddF32(FlatBufferBuilder builder, float f32) { builder.AddFloat(8, f32, 0.0f); } + public static void AddF64(FlatBufferBuilder builder, double f64) { builder.AddDouble(9, f64, 0.0); } + public static void AddV8(FlatBufferBuilder builder, VectorOffset v8Offset) { builder.AddOffset(10, v8Offset.Value, 0); } + public static VectorOffset CreateV8Vector(FlatBufferBuilder builder, sbyte[] data) { builder.StartVector(1, data.Length, 1); for (int i = data.Length - 1; i >= 0; i--) builder.AddSbyte(data[i]); return builder.EndVector(); } + public static void StartV8Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(1, numElems, 1); } + public static void AddVf64(FlatBufferBuilder builder, VectorOffset vf64Offset) { builder.AddOffset(11, vf64Offset.Value, 0); } + public static VectorOffset CreateVf64Vector(FlatBufferBuilder builder, double[] data) { builder.StartVector(8, data.Length, 8); for (int i = data.Length - 1; i >= 0; i--) builder.AddDouble(data[i]); return builder.EndVector(); } + public static void StartVf64Vector(FlatBufferBuilder builder, int numElems) { builder.StartVector(8, numElems, 8); } + public static Offset EndTypeAliases(FlatBufferBuilder builder) { + int o = builder.EndObject(); + return new Offset(o); + } +}; + + +} diff --git a/tests/MyGame/Example/TypeAliases.go b/tests/MyGame/Example/TypeAliases.go new file mode 100644 index 000000000..c64c2879f --- /dev/null +++ b/tests/MyGame/Example/TypeAliases.go @@ -0,0 +1,230 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package Example + +import ( + flatbuffers "github.com/google/flatbuffers/go" +) + +type TypeAliases struct { + _tab flatbuffers.Table +} + +func GetRootAsTypeAliases(buf []byte, offset flatbuffers.UOffsetT) *TypeAliases { + n := flatbuffers.GetUOffsetT(buf[offset:]) + x := &TypeAliases{} + x.Init(buf, n+offset) + return x +} + +func (rcv *TypeAliases) Init(buf []byte, i flatbuffers.UOffsetT) { + rcv._tab.Bytes = buf + rcv._tab.Pos = i +} + +func (rcv *TypeAliases) Table() flatbuffers.Table { + return rcv._tab +} + +func (rcv *TypeAliases) I8() int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(4)) + if o != 0 { + return rcv._tab.GetInt8(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateI8(n int8) bool { + return rcv._tab.MutateInt8Slot(4, n) +} + +func (rcv *TypeAliases) U8() byte { + o := flatbuffers.UOffsetT(rcv._tab.Offset(6)) + if o != 0 { + return rcv._tab.GetByte(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateU8(n byte) bool { + return rcv._tab.MutateByteSlot(6, n) +} + +func (rcv *TypeAliases) I16() int16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(8)) + if o != 0 { + return rcv._tab.GetInt16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateI16(n int16) bool { + return rcv._tab.MutateInt16Slot(8, n) +} + +func (rcv *TypeAliases) U16() uint16 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(10)) + if o != 0 { + return rcv._tab.GetUint16(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateU16(n uint16) bool { + return rcv._tab.MutateUint16Slot(10, n) +} + +func (rcv *TypeAliases) I32() int32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(12)) + if o != 0 { + return rcv._tab.GetInt32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateI32(n int32) bool { + return rcv._tab.MutateInt32Slot(12, n) +} + +func (rcv *TypeAliases) U32() uint32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(14)) + if o != 0 { + return rcv._tab.GetUint32(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateU32(n uint32) bool { + return rcv._tab.MutateUint32Slot(14, n) +} + +func (rcv *TypeAliases) I64() int64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(16)) + if o != 0 { + return rcv._tab.GetInt64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateI64(n int64) bool { + return rcv._tab.MutateInt64Slot(16, n) +} + +func (rcv *TypeAliases) U64() uint64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(18)) + if o != 0 { + return rcv._tab.GetUint64(o + rcv._tab.Pos) + } + return 0 +} + +func (rcv *TypeAliases) MutateU64(n uint64) bool { + return rcv._tab.MutateUint64Slot(18, n) +} + +func (rcv *TypeAliases) F32() float32 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(20)) + if o != 0 { + return rcv._tab.GetFloat32(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *TypeAliases) MutateF32(n float32) bool { + return rcv._tab.MutateFloat32Slot(20, n) +} + +func (rcv *TypeAliases) F64() float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(22)) + if o != 0 { + return rcv._tab.GetFloat64(o + rcv._tab.Pos) + } + return 0.0 +} + +func (rcv *TypeAliases) MutateF64(n float64) bool { + return rcv._tab.MutateFloat64Slot(22, n) +} + +func (rcv *TypeAliases) V8(j int) int8 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetInt8(a + flatbuffers.UOffsetT(j*1)) + } + return 0 +} + +func (rcv *TypeAliases) V8Length() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(24)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func (rcv *TypeAliases) Vf64(j int) float64 { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + a := rcv._tab.Vector(o) + return rcv._tab.GetFloat64(a + flatbuffers.UOffsetT(j*8)) + } + return 0 +} + +func (rcv *TypeAliases) Vf64Length() int { + o := flatbuffers.UOffsetT(rcv._tab.Offset(26)) + if o != 0 { + return rcv._tab.VectorLen(o) + } + return 0 +} + +func TypeAliasesStart(builder *flatbuffers.Builder) { + builder.StartObject(12) +} +func TypeAliasesAddI8(builder *flatbuffers.Builder, i8 int8) { + builder.PrependInt8Slot(0, i8, 0) +} +func TypeAliasesAddU8(builder *flatbuffers.Builder, u8 byte) { + builder.PrependByteSlot(1, u8, 0) +} +func TypeAliasesAddI16(builder *flatbuffers.Builder, i16 int16) { + builder.PrependInt16Slot(2, i16, 0) +} +func TypeAliasesAddU16(builder *flatbuffers.Builder, u16 uint16) { + builder.PrependUint16Slot(3, u16, 0) +} +func TypeAliasesAddI32(builder *flatbuffers.Builder, i32 int32) { + builder.PrependInt32Slot(4, i32, 0) +} +func TypeAliasesAddU32(builder *flatbuffers.Builder, u32 uint32) { + builder.PrependUint32Slot(5, u32, 0) +} +func TypeAliasesAddI64(builder *flatbuffers.Builder, i64 int64) { + builder.PrependInt64Slot(6, i64, 0) +} +func TypeAliasesAddU64(builder *flatbuffers.Builder, u64 uint64) { + builder.PrependUint64Slot(7, u64, 0) +} +func TypeAliasesAddF32(builder *flatbuffers.Builder, f32 float32) { + builder.PrependFloat32Slot(8, f32, 0.0) +} +func TypeAliasesAddF64(builder *flatbuffers.Builder, f64 float64) { + builder.PrependFloat64Slot(9, f64, 0.0) +} +func TypeAliasesAddV8(builder *flatbuffers.Builder, v8 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(10, flatbuffers.UOffsetT(v8), 0) +} +func TypeAliasesStartV8Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(1, numElems, 1) +} +func TypeAliasesAddVf64(builder *flatbuffers.Builder, vf64 flatbuffers.UOffsetT) { + builder.PrependUOffsetTSlot(11, flatbuffers.UOffsetT(vf64), 0) +} +func TypeAliasesStartVf64Vector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT { + return builder.StartVector(8, numElems, 8) +} +func TypeAliasesEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT { + return builder.EndObject() +} diff --git a/tests/MyGame/Example/TypeAliases.java b/tests/MyGame/Example/TypeAliases.java new file mode 100644 index 000000000..a5cff0c82 --- /dev/null +++ b/tests/MyGame/Example/TypeAliases.java @@ -0,0 +1,97 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +package MyGame.Example; + +import java.nio.*; +import java.lang.*; +import java.util.*; +import com.google.flatbuffers.*; + +@SuppressWarnings("unused") +public final class TypeAliases extends Table { + public static TypeAliases getRootAsTypeAliases(ByteBuffer _bb) { return getRootAsTypeAliases(_bb, new TypeAliases()); } + public static TypeAliases getRootAsTypeAliases(ByteBuffer _bb, TypeAliases obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); } + public void __init(int _i, ByteBuffer _bb) { bb_pos = _i; bb = _bb; } + public TypeAliases __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; } + + public byte i8() { int o = __offset(4); return o != 0 ? bb.get(o + bb_pos) : 0; } + public boolean mutateI8(byte i8) { int o = __offset(4); if (o != 0) { bb.put(o + bb_pos, i8); return true; } else { return false; } } + public int u8() { int o = __offset(6); return o != 0 ? bb.get(o + bb_pos) & 0xFF : 0; } + public boolean mutateU8(int u8) { int o = __offset(6); if (o != 0) { bb.put(o + bb_pos, (byte)u8); return true; } else { return false; } } + public short i16() { int o = __offset(8); return o != 0 ? bb.getShort(o + bb_pos) : 0; } + public boolean mutateI16(short i16) { int o = __offset(8); if (o != 0) { bb.putShort(o + bb_pos, i16); return true; } else { return false; } } + public int u16() { int o = __offset(10); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; } + public boolean mutateU16(int u16) { int o = __offset(10); if (o != 0) { bb.putShort(o + bb_pos, (short)u16); return true; } else { return false; } } + public int i32() { int o = __offset(12); return o != 0 ? bb.getInt(o + bb_pos) : 0; } + public boolean mutateI32(int i32) { int o = __offset(12); if (o != 0) { bb.putInt(o + bb_pos, i32); return true; } else { return false; } } + public long u32() { int o = __offset(14); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; } + public boolean mutateU32(long u32) { int o = __offset(14); if (o != 0) { bb.putInt(o + bb_pos, (int)u32); return true; } else { return false; } } + public long i64() { int o = __offset(16); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } + public boolean mutateI64(long i64) { int o = __offset(16); if (o != 0) { bb.putLong(o + bb_pos, i64); return true; } else { return false; } } + public long u64() { int o = __offset(18); return o != 0 ? bb.getLong(o + bb_pos) : 0L; } + public boolean mutateU64(long u64) { int o = __offset(18); if (o != 0) { bb.putLong(o + bb_pos, u64); return true; } else { return false; } } + public float f32() { int o = __offset(20); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; } + public boolean mutateF32(float f32) { int o = __offset(20); if (o != 0) { bb.putFloat(o + bb_pos, f32); return true; } else { return false; } } + public double f64() { int o = __offset(22); return o != 0 ? bb.getDouble(o + bb_pos) : 0.0; } + public boolean mutateF64(double f64) { int o = __offset(22); if (o != 0) { bb.putDouble(o + bb_pos, f64); return true; } else { return false; } } + public byte v8(int j) { int o = __offset(24); return o != 0 ? bb.get(__vector(o) + j * 1) : 0; } + public int v8Length() { int o = __offset(24); return o != 0 ? __vector_len(o) : 0; } + public ByteBuffer v8AsByteBuffer() { return __vector_as_bytebuffer(24, 1); } + public boolean mutateV8(int j, byte v8) { int o = __offset(24); if (o != 0) { bb.put(__vector(o) + j * 1, v8); return true; } else { return false; } } + public double vf64(int j) { int o = __offset(26); return o != 0 ? bb.getDouble(__vector(o) + j * 8) : 0; } + public int vf64Length() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; } + public ByteBuffer vf64AsByteBuffer() { return __vector_as_bytebuffer(26, 8); } + public boolean mutateVf64(int j, double vf64) { int o = __offset(26); if (o != 0) { bb.putDouble(__vector(o) + j * 8, vf64); return true; } else { return false; } } + + public static int createTypeAliases(FlatBufferBuilder builder, + byte i8, + int u8, + short i16, + int u16, + int i32, + long u32, + long i64, + long u64, + float f32, + double f64, + int v8Offset, + int vf64Offset) { + builder.startObject(12); + TypeAliases.addF64(builder, f64); + TypeAliases.addU64(builder, u64); + TypeAliases.addI64(builder, i64); + TypeAliases.addVf64(builder, vf64Offset); + TypeAliases.addV8(builder, v8Offset); + TypeAliases.addF32(builder, f32); + TypeAliases.addU32(builder, u32); + TypeAliases.addI32(builder, i32); + TypeAliases.addU16(builder, u16); + TypeAliases.addI16(builder, i16); + TypeAliases.addU8(builder, u8); + TypeAliases.addI8(builder, i8); + return TypeAliases.endTypeAliases(builder); + } + + public static void startTypeAliases(FlatBufferBuilder builder) { builder.startObject(12); } + public static void addI8(FlatBufferBuilder builder, byte i8) { builder.addByte(0, i8, 0); } + public static void addU8(FlatBufferBuilder builder, int u8) { builder.addByte(1, (byte)u8, (byte)0); } + public static void addI16(FlatBufferBuilder builder, short i16) { builder.addShort(2, i16, 0); } + public static void addU16(FlatBufferBuilder builder, int u16) { builder.addShort(3, (short)u16, (short)0); } + public static void addI32(FlatBufferBuilder builder, int i32) { builder.addInt(4, i32, 0); } + public static void addU32(FlatBufferBuilder builder, long u32) { builder.addInt(5, (int)u32, (int)0L); } + public static void addI64(FlatBufferBuilder builder, long i64) { builder.addLong(6, i64, 0L); } + public static void addU64(FlatBufferBuilder builder, long u64) { builder.addLong(7, u64, 0L); } + public static void addF32(FlatBufferBuilder builder, float f32) { builder.addFloat(8, f32, 0.0f); } + public static void addF64(FlatBufferBuilder builder, double f64) { builder.addDouble(9, f64, 0.0); } + public static void addV8(FlatBufferBuilder builder, int v8Offset) { builder.addOffset(10, v8Offset, 0); } + public static int createV8Vector(FlatBufferBuilder builder, byte[] data) { builder.startVector(1, data.length, 1); for (int i = data.length - 1; i >= 0; i--) builder.addByte(data[i]); return builder.endVector(); } + public static void startV8Vector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); } + public static void addVf64(FlatBufferBuilder builder, int vf64Offset) { builder.addOffset(11, vf64Offset, 0); } + public static int createVf64Vector(FlatBufferBuilder builder, double[] data) { builder.startVector(8, data.length, 8); for (int i = data.length - 1; i >= 0; i--) builder.addDouble(data[i]); return builder.endVector(); } + public static void startVf64Vector(FlatBufferBuilder builder, int numElems) { builder.startVector(8, numElems, 8); } + public static int endTypeAliases(FlatBufferBuilder builder) { + int o = builder.endObject(); + return o; + } +} + diff --git a/tests/MyGame/Example/TypeAliases.php b/tests/MyGame/Example/TypeAliases.php new file mode 100644 index 000000000..ecf804dfd --- /dev/null +++ b/tests/MyGame/Example/TypeAliases.php @@ -0,0 +1,387 @@ +init($bb->getInt($bb->getPosition()) + $bb->getPosition(), $bb)); + } + + public static function TypeAliasesIdentifier() + { + return "MONS"; + } + + public static function TypeAliasesBufferHasIdentifier(ByteBuffer $buf) + { + return self::__has_identifier($buf, self::TypeAliasesIdentifier()); + } + + public static function TypeAliasesExtension() + { + return "mon"; + } + + /** + * @param int $_i offset + * @param ByteBuffer $_bb + * @return TypeAliases + **/ + public function init($_i, ByteBuffer $_bb) + { + $this->bb_pos = $_i; + $this->bb = $_bb; + return $this; + } + + /** + * @return sbyte + */ + public function getI8() + { + $o = $this->__offset(4); + return $o != 0 ? $this->bb->getSbyte($o + $this->bb_pos) : 0; + } + + /** + * @return byte + */ + public function getU8() + { + $o = $this->__offset(6); + return $o != 0 ? $this->bb->getByte($o + $this->bb_pos) : 0; + } + + /** + * @return short + */ + public function getI16() + { + $o = $this->__offset(8); + return $o != 0 ? $this->bb->getShort($o + $this->bb_pos) : 0; + } + + /** + * @return ushort + */ + public function getU16() + { + $o = $this->__offset(10); + return $o != 0 ? $this->bb->getUshort($o + $this->bb_pos) : 0; + } + + /** + * @return int + */ + public function getI32() + { + $o = $this->__offset(12); + return $o != 0 ? $this->bb->getInt($o + $this->bb_pos) : 0; + } + + /** + * @return uint + */ + public function getU32() + { + $o = $this->__offset(14); + return $o != 0 ? $this->bb->getUint($o + $this->bb_pos) : 0; + } + + /** + * @return long + */ + public function getI64() + { + $o = $this->__offset(16); + return $o != 0 ? $this->bb->getLong($o + $this->bb_pos) : 0; + } + + /** + * @return ulong + */ + public function getU64() + { + $o = $this->__offset(18); + return $o != 0 ? $this->bb->getUlong($o + $this->bb_pos) : 0; + } + + /** + * @return float + */ + public function getF32() + { + $o = $this->__offset(20); + return $o != 0 ? $this->bb->getFloat($o + $this->bb_pos) : 0.0; + } + + /** + * @return double + */ + public function getF64() + { + $o = $this->__offset(22); + return $o != 0 ? $this->bb->getDouble($o + $this->bb_pos) : 0.0; + } + + /** + * @param int offset + * @return sbyte + */ + public function getV8($j) + { + $o = $this->__offset(24); + return $o != 0 ? $this->bb->getSbyte($this->__vector($o) + $j * 1) : 0; + } + + /** + * @return int + */ + public function getV8Length() + { + $o = $this->__offset(24); + return $o != 0 ? $this->__vector_len($o) : 0; + } + + /** + * @param int offset + * @return double + */ + public function getVf64($j) + { + $o = $this->__offset(26); + return $o != 0 ? $this->bb->getDouble($this->__vector($o) + $j * 8) : 0; + } + + /** + * @return int + */ + public function getVf64Length() + { + $o = $this->__offset(26); + return $o != 0 ? $this->__vector_len($o) : 0; + } + + /** + * @param FlatBufferBuilder $builder + * @return void + */ + public static function startTypeAliases(FlatBufferBuilder $builder) + { + $builder->StartObject(12); + } + + /** + * @param FlatBufferBuilder $builder + * @return TypeAliases + */ + public static function createTypeAliases(FlatBufferBuilder $builder, $i8, $u8, $i16, $u16, $i32, $u32, $i64, $u64, $f32, $f64, $v8, $vf64) + { + $builder->startObject(12); + self::addI8($builder, $i8); + self::addU8($builder, $u8); + self::addI16($builder, $i16); + self::addU16($builder, $u16); + self::addI32($builder, $i32); + self::addU32($builder, $u32); + self::addI64($builder, $i64); + self::addU64($builder, $u64); + self::addF32($builder, $f32); + self::addF64($builder, $f64); + self::addV8($builder, $v8); + self::addVf64($builder, $vf64); + $o = $builder->endObject(); + return $o; + } + + /** + * @param FlatBufferBuilder $builder + * @param sbyte + * @return void + */ + public static function addI8(FlatBufferBuilder $builder, $i8) + { + $builder->addSbyteX(0, $i8, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param byte + * @return void + */ + public static function addU8(FlatBufferBuilder $builder, $u8) + { + $builder->addByteX(1, $u8, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param short + * @return void + */ + public static function addI16(FlatBufferBuilder $builder, $i16) + { + $builder->addShortX(2, $i16, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param ushort + * @return void + */ + public static function addU16(FlatBufferBuilder $builder, $u16) + { + $builder->addUshortX(3, $u16, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param int + * @return void + */ + public static function addI32(FlatBufferBuilder $builder, $i32) + { + $builder->addIntX(4, $i32, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param uint + * @return void + */ + public static function addU32(FlatBufferBuilder $builder, $u32) + { + $builder->addUintX(5, $u32, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param long + * @return void + */ + public static function addI64(FlatBufferBuilder $builder, $i64) + { + $builder->addLongX(6, $i64, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param ulong + * @return void + */ + public static function addU64(FlatBufferBuilder $builder, $u64) + { + $builder->addUlongX(7, $u64, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param float + * @return void + */ + public static function addF32(FlatBufferBuilder $builder, $f32) + { + $builder->addFloatX(8, $f32, 0.0); + } + + /** + * @param FlatBufferBuilder $builder + * @param double + * @return void + */ + public static function addF64(FlatBufferBuilder $builder, $f64) + { + $builder->addDoubleX(9, $f64, 0.0); + } + + /** + * @param FlatBufferBuilder $builder + * @param VectorOffset + * @return void + */ + public static function addV8(FlatBufferBuilder $builder, $v8) + { + $builder->addOffsetX(10, $v8, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param array offset array + * @return int vector offset + */ + public static function createV8Vector(FlatBufferBuilder $builder, array $data) + { + $builder->startVector(1, count($data), 1); + for ($i = count($data) - 1; $i >= 0; $i--) { + $builder->addSbyte($data[$i]); + } + return $builder->endVector(); + } + + /** + * @param FlatBufferBuilder $builder + * @param int $numElems + * @return void + */ + public static function startV8Vector(FlatBufferBuilder $builder, $numElems) + { + $builder->startVector(1, $numElems, 1); + } + + /** + * @param FlatBufferBuilder $builder + * @param VectorOffset + * @return void + */ + public static function addVf64(FlatBufferBuilder $builder, $vf64) + { + $builder->addOffsetX(11, $vf64, 0); + } + + /** + * @param FlatBufferBuilder $builder + * @param array offset array + * @return int vector offset + */ + public static function createVf64Vector(FlatBufferBuilder $builder, array $data) + { + $builder->startVector(8, count($data), 8); + for ($i = count($data) - 1; $i >= 0; $i--) { + $builder->addDouble($data[$i]); + } + return $builder->endVector(); + } + + /** + * @param FlatBufferBuilder $builder + * @param int $numElems + * @return void + */ + public static function startVf64Vector(FlatBufferBuilder $builder, $numElems) + { + $builder->startVector(8, $numElems, 8); + } + + /** + * @param FlatBufferBuilder $builder + * @return int table offset + */ + public static function endTypeAliases(FlatBufferBuilder $builder) + { + $o = $builder->endObject(); + return $o; + } +} diff --git a/tests/MyGame/Example/TypeAliases.py b/tests/MyGame/Example/TypeAliases.py new file mode 100644 index 000000000..707e53f14 --- /dev/null +++ b/tests/MyGame/Example/TypeAliases.py @@ -0,0 +1,150 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# namespace: Example + +import flatbuffers + +class TypeAliases(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTypeAliases(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TypeAliases() + x.Init(buf, n + offset) + return x + + # TypeAliases + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TypeAliases + def I8(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 + + # TypeAliases + def U8(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # TypeAliases + def I16(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos) + return 0 + + # TypeAliases + def U16(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint16Flags, o + self._tab.Pos) + return 0 + + # TypeAliases + def I32(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # TypeAliases + def U32(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # TypeAliases + def I64(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int64Flags, o + self._tab.Pos) + return 0 + + # TypeAliases + def U64(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint64Flags, o + self._tab.Pos) + return 0 + + # TypeAliases + def F32(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # TypeAliases + def F64(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(22)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float64Flags, o + self._tab.Pos) + return 0.0 + + # TypeAliases + def V8(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1)) + return 0 + + # TypeAliases + def V8AsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int8Flags, o) + return 0 + + # TypeAliases + def V8Length(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(24)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TypeAliases + def Vf64(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Float64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8)) + return 0 + + # TypeAliases + def Vf64AsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float64Flags, o) + return 0 + + # TypeAliases + def Vf64Length(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(26)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def TypeAliasesStart(builder): builder.StartObject(12) +def TypeAliasesAddI8(builder, i8): builder.PrependInt8Slot(0, i8, 0) +def TypeAliasesAddU8(builder, u8): builder.PrependUint8Slot(1, u8, 0) +def TypeAliasesAddI16(builder, i16): builder.PrependInt16Slot(2, i16, 0) +def TypeAliasesAddU16(builder, u16): builder.PrependUint16Slot(3, u16, 0) +def TypeAliasesAddI32(builder, i32): builder.PrependInt32Slot(4, i32, 0) +def TypeAliasesAddU32(builder, u32): builder.PrependUint32Slot(5, u32, 0) +def TypeAliasesAddI64(builder, i64): builder.PrependInt64Slot(6, i64, 0) +def TypeAliasesAddU64(builder, u64): builder.PrependUint64Slot(7, u64, 0) +def TypeAliasesAddF32(builder, f32): builder.PrependFloat32Slot(8, f32, 0.0) +def TypeAliasesAddF64(builder, f64): builder.PrependFloat64Slot(9, f64, 0.0) +def TypeAliasesAddV8(builder, v8): builder.PrependUOffsetTRelativeSlot(10, flatbuffers.number_types.UOffsetTFlags.py_type(v8), 0) +def TypeAliasesStartV8Vector(builder, numElems): return builder.StartVector(1, numElems, 1) +def TypeAliasesAddVf64(builder, vf64): builder.PrependUOffsetTRelativeSlot(11, flatbuffers.number_types.UOffsetTFlags.py_type(vf64), 0) +def TypeAliasesStartVf64Vector(builder, numElems): return builder.StartVector(8, numElems, 8) +def TypeAliasesEnd(builder): return builder.EndObject() diff --git a/tests/monster_test.bfbs b/tests/monster_test.bfbs index e94b8015ae974765399a3454336e25f6f28a01e2..fc20d89eea10785187d38bc31995344a9c4b114b 100644 GIT binary patch literal 5328 zcmai2U1%KF6+SDiRx4?xRqU;zII24~Mu=cUEGb5qV(g9WIL1H4R$V`YD6`sGYs~D- zGCRAmgfS%)Q-U!e1QS9jArGeH!4IXB67o<&=|d@@6hD*_`V>qFsq4CJnqN=9@7@_{ zG_!6m9NoY3f6knHw38xIJyty@GA5Ifm!gzpTq@X!ECTibDu5y&7!c{l-1J;vikv!g z8g%;XB<44A!08hi!TP1L$PwWG1dJ-%L|%AIO_7&0yFZXY4P|h;zymyZ^>#0 z=WOb-WY!$(2X?S})a^9Ej~?ITX8?B`MC7du#9aNGvbW4V_1n~?6#0an+w{>-ABG|2 zo<4K>C??qpyPw9K_TyWcZ$J6c7uNw70DA!pOUj4OdXDGgIMSICwcJUpXg~8K9=jov zI#ivG#j}sFCr?tvemaITq=!7`Tb8TtDzImhZ;T)Np$mNKdDf~!9&ss=_~T0c3|46y zuijI>8=_3|VLtByM7Es?RxSTDGUZ&$T(M@4`CjvRcg5+{sdNcn0BuOyDKZ?LbEP4o zI&V56>wgc!<2a{JC{y#$n*JX9w*kMv#Y=z^;B&wgzzpCH?tYDV3G*Jn4nQgnOKUCb zuw$ETt1a^Iei)7bi!q=lVp%snqupaA?z@fs3z+1oe}v&MFw?m2Y21GLs0#<31>TTM zWbnR(ETEJa1F~EPUJ-Ff^V^Mcpo}QI`8jz9`$2q_X}l8}ZjcNXz|D*pKlUQOevc-X+BUp@lONdQtq#W!&H~_L;J=Cahfsb2_oc!gVVYo|<1$#*ld zx?0vK-@GJk;M?xSIgy?J4#OwqK!)zO;0KZsgjCTr=CME>nNl@9kL=ZN08d%TSci6? zdK#E30M;5kiibE)Kn|u&evnNH~IF5`L(8p2KvIY1FvKWiCVap_VbsJR;qy*&(w>$omlY6}-UoNwS`IHQiv6uAQJO{3i^z z%TpP;+nR1T_Dj+}h>(Mz+a@y^y1SZgC`lLFN4hTP9+T+|-Aayb zY5UG=y1^t}Y#-_F;=YWkm8QF)>H1KrRQwol;!k`YhGWRSbU&cqMJb~M$xuXNHCqAN zLpcGOQQ4W1@#k;UH=1YOGe=y2Rc|bIsn{Xm*^yc5K%&0?!k9o@f8R)(5M0+j!Y_9K&+!MyF-iu7Nhk zxCq(43C-~=sQ%_v^izw4%G^E2Xr?<#~xw^ zYsQQ==`oDFE})Mss@{q6lXaDi${#_?z9Q{Q#s}9-5yg+O;JObrko`p(e_i9}h!e+p zIY9S>y$}7_YwW=~u4l}lcrZR#tKOJ#TZx)q7qZxUkS=XkQQ4*YLD-e2Oxx|^0rvbg z#Ci&rv(snKs5^Pep2UqBIrb{w!}16q`R&sH?%8d#=cS%>0)5K6eE^=deB1MFmCABU zy$hngi-vC_6C9)+`^2OU5@}qCbjam;^+69buTjc#(JODQ>-1hc^gF>GDfSQbtjE{U zTvfGN2AJ=wEgmM{oh(20QUEphq0eTPyQY0M7xHM_a!g#s_3uYRo(i_5+_5r)$P-jlc2Tv&OKMX#l?;nx<_V z)3%ftXX5f(d>v=K{!cidaYvYE>wx#L@8$Pe0*`OSJJ_e?UQ6Iy2F^YBn6{+zn6gd+ zrU9w^U4pv3ev$xY+_$klFhcQ&W1Qcp>y*d1CdUIE?+qX7+R6INyx}iA|50Y3N=Hyr~UC4N(if0LS$Dy4|TRAVa|i%IRSVUl@c24>z1Z{7qW zMY3|?B9tyl=|YN#6c^&6h!p8UM7rprh>Ie{g^SXK6p_|yYdihEd)}Ryq(kWqC+EF) zzkB}gxp#&{WMXn+8VsXP1|=#nNyr8nz?)w&gN4Ix zwJZ-qdGtSFqTG3>Eva}=-&W5wR4Ti=M()J18oO|zMTjb9DfRx zF};|ZcSa_Cul%k%U#jM5Ed3b*efZ48Fi!gt_@h78c4|q3Sl8joQ@Ije@I`StmqiX~ zLk2{-n?dX1Yf~mWF!vRL@DT(=0nVV1?tt#&+e`3|L1`p8jrYgE+ys62-d8~5pc3A{1U3pj4!#?F0sIb#N%$V`^oy~2gxqeIN%PKFYy>Si z^MU8jdWG4%S4E*#@a@{4j8R{rAF)cKGPs^O!d7m=mpu1$MIIiOR?hcx%U+@4`GJ$K z1b%fskP%%&)8sbR4WUcXUi!yg(Y!A3i|*;H$f~aCeG2?md8=*ysDTq-sQ9jv zz$eiG=r8*mIpfbn;ZZs<57u@Tyid|~Ts*`%<;4I;oAjIgBS~)QE5P>3HiJ#$opLGD z1v&XbDHqID3k4ip7)$7%*vHWaSi`f6`t9CyT&GOgZYUeAMB4tS)p}6X>+=)tyMPB7 z3+$50HRsSitm#H~;F=7`){Nb&X3wF2#;_}Rma(_Ord}88;^>@Q$GW%mJ_ba>U}F|* z`o=}zWAN7cz`jAh!6a+;vu@A3z;$8g6UW%tSk4B^iw@phjXB-LXx`t=yPGrI$GrV$ zFQGg;XzP4GG=DeIhEIV*pB9=XYx{L0TcO=pdD=Cvvp>7xFDwuq&_0szQHP8kG=NY3sCox!~3yUJ#7?%$EX#3~C;~Oy% z*8G2JR;#XZ&du>v&jaZ=X>>Mj0X#<*y^8F@T?daz#`G>Qj7=KEIBf#0JCmn_Twv}N z#4)BjLC;_({jk1jZmTW}>x$;KGlhOiTZ!RX>R-ae;I7WcpRTiyF(@J+Kk0n$Rnw0p z!U#|&<4IX9?hOa$iY1dl${^+t=yRiA{b#KCJzvCm=+2v*T%i0|%G46=YmDZcN`&h; zZ|ys;cEyfr9F2V$%+t;^s6`AGCvJn=T+&b0!C4S>f%QBB zk0AOs4xHzvSPkd7zIl$965gk|b{L#8$3R>+3|d!TGcc#smEYjgz_Y99e$d`xK862u z-|^Rl?g!?GL+ep5>tVf{c<^?kviNI>RiXDCuzDUTBMNGfN7`!YAdmSph_>l35xwh} zPvJk>76F>Ep(gr2hwOA3>%yMio;};m_VU)h yF^t9uOdDL95A`@Q$7_ep@%mWwt*!SY&kb6^)2{JrxRKxgXWRR3wSpf};rIta5%4nr diff --git a/tests/monster_test.fbs b/tests/monster_test.fbs index a199e90b3..41cacef82 100755 --- a/tests/monster_test.fbs +++ b/tests/monster_test.fbs @@ -79,6 +79,21 @@ table Monster { vector_of_doubles:[double] (id:33); } +table TypeAliases { + i8:int8; + u8:uint8; + i16:int16; + u16:uint16; + i32:int32; + u32:uint32; + i64:int64; + u64:uint64; + f32:float32; + f64:float64; + v8:[int8]; + vf64:[float64]; +} + rpc_service MonsterStorage { Store(Monster):Stat (streaming: "none"); Retrieve(Stat):Monster (streaming: "server", idempotent); diff --git a/tests/monster_test.schema.json b/tests/monster_test.schema.json index 43675fa4e..9af53bb7a 100644 --- a/tests/monster_test.schema.json +++ b/tests/monster_test.schema.json @@ -114,6 +114,23 @@ "vector_of_doubles" : { "type" : "array", "items" : { "type" : "number" } } }, "required" : [ "name"] + }, + "MyGame_Example_TypeAliases" : { + "type" : "object", + "properties" : { + "i8" : { "type" : "number" }, + "u8" : { "type" : "number" }, + "i16" : { "type" : "number" }, + "u16" : { "type" : "number" }, + "i32" : { "type" : "number" }, + "u32" : { "type" : "number" }, + "i64" : { "type" : "number" }, + "u64" : { "type" : "number" }, + "f32" : { "type" : "number" }, + "f64" : { "type" : "number" }, + "v8" : { "type" : "array", "items" : { "type" : "number" } }, + "vf64" : { "type" : "array", "items" : { "type" : "number" } } + } } }, "$ref" : "#/definitions/MyGame_Example_Monster" diff --git a/tests/monster_test_generated.h b/tests/monster_test_generated.h index 0206e55f5..b105f5a9d 100644 --- a/tests/monster_test_generated.h +++ b/tests/monster_test_generated.h @@ -32,6 +32,9 @@ struct StatT; struct Monster; struct MonsterT; +struct TypeAliases; +struct TypeAliasesT; + enum Color { Color_Red = 1, Color_Green = 2, @@ -518,7 +521,7 @@ flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const struct MonsterT : public flatbuffers::NativeTable { typedef Monster TableType; - std::unique_ptr pos; + flatbuffers::unique_ptr pos; int16_t mana; int16_t hp; std::string name; @@ -527,10 +530,10 @@ struct MonsterT : public flatbuffers::NativeTable { AnyUnion test; std::vector test4; std::vector testarrayofstring; - std::vector> testarrayoftables; - std::unique_ptr enemy; + std::vector> testarrayoftables; + flatbuffers::unique_ptr enemy; std::vector testnestedflatbuffer; - std::unique_ptr testempty; + flatbuffers::unique_ptr testempty; bool testbool; int32_t testhashs32_fnv1; uint32_t testhashu32_fnv1; @@ -1165,6 +1168,258 @@ inline flatbuffers::Offset CreateMonsterDirect( flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +struct TypeAliasesT : public flatbuffers::NativeTable { + typedef TypeAliases TableType; + int8_t i8; + uint8_t u8; + int16_t i16; + uint16_t u16; + int32_t i32; + uint32_t u32; + int64_t i64; + uint64_t u64; + float f32; + double f64; + std::vector v8; + std::vector vf64; + TypeAliasesT() + : i8(0), + u8(0), + i16(0), + u16(0), + i32(0), + u32(0), + i64(0), + u64(0), + f32(0.0f), + f64(0.0) { + } +}; + +struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TypeAliasesT NativeTableType; + enum { + VT_I8 = 4, + VT_U8 = 6, + VT_I16 = 8, + VT_U16 = 10, + VT_I32 = 12, + VT_U32 = 14, + VT_I64 = 16, + VT_U64 = 18, + VT_F32 = 20, + VT_F64 = 22, + VT_V8 = 24, + VT_VF64 = 26 + }; + int8_t i8() const { + return GetField(VT_I8, 0); + } + bool mutate_i8(int8_t _i8) { + return SetField(VT_I8, _i8, 0); + } + uint8_t u8() const { + return GetField(VT_U8, 0); + } + bool mutate_u8(uint8_t _u8) { + return SetField(VT_U8, _u8, 0); + } + int16_t i16() const { + return GetField(VT_I16, 0); + } + bool mutate_i16(int16_t _i16) { + return SetField(VT_I16, _i16, 0); + } + uint16_t u16() const { + return GetField(VT_U16, 0); + } + bool mutate_u16(uint16_t _u16) { + return SetField(VT_U16, _u16, 0); + } + int32_t i32() const { + return GetField(VT_I32, 0); + } + bool mutate_i32(int32_t _i32) { + return SetField(VT_I32, _i32, 0); + } + uint32_t u32() const { + return GetField(VT_U32, 0); + } + bool mutate_u32(uint32_t _u32) { + return SetField(VT_U32, _u32, 0); + } + int64_t i64() const { + return GetField(VT_I64, 0); + } + bool mutate_i64(int64_t _i64) { + return SetField(VT_I64, _i64, 0); + } + uint64_t u64() const { + return GetField(VT_U64, 0); + } + bool mutate_u64(uint64_t _u64) { + return SetField(VT_U64, _u64, 0); + } + float f32() const { + return GetField(VT_F32, 0.0f); + } + bool mutate_f32(float _f32) { + return SetField(VT_F32, _f32, 0.0f); + } + double f64() const { + return GetField(VT_F64, 0.0); + } + bool mutate_f64(double _f64) { + return SetField(VT_F64, _f64, 0.0); + } + const flatbuffers::Vector *v8() const { + return GetPointer *>(VT_V8); + } + flatbuffers::Vector *mutable_v8() { + return GetPointer *>(VT_V8); + } + const flatbuffers::Vector *vf64() const { + return GetPointer *>(VT_VF64); + } + flatbuffers::Vector *mutable_vf64() { + return GetPointer *>(VT_VF64); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_I8) && + VerifyField(verifier, VT_U8) && + VerifyField(verifier, VT_I16) && + VerifyField(verifier, VT_U16) && + VerifyField(verifier, VT_I32) && + VerifyField(verifier, VT_U32) && + VerifyField(verifier, VT_I64) && + VerifyField(verifier, VT_U64) && + VerifyField(verifier, VT_F32) && + VerifyField(verifier, VT_F64) && + VerifyOffset(verifier, VT_V8) && + verifier.Verify(v8()) && + VerifyOffset(verifier, VT_VF64) && + verifier.Verify(vf64()) && + verifier.EndTable(); + } + TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TypeAliasesBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_i8(int8_t i8) { + fbb_.AddElement(TypeAliases::VT_I8, i8, 0); + } + void add_u8(uint8_t u8) { + fbb_.AddElement(TypeAliases::VT_U8, u8, 0); + } + void add_i16(int16_t i16) { + fbb_.AddElement(TypeAliases::VT_I16, i16, 0); + } + void add_u16(uint16_t u16) { + fbb_.AddElement(TypeAliases::VT_U16, u16, 0); + } + void add_i32(int32_t i32) { + fbb_.AddElement(TypeAliases::VT_I32, i32, 0); + } + void add_u32(uint32_t u32) { + fbb_.AddElement(TypeAliases::VT_U32, u32, 0); + } + void add_i64(int64_t i64) { + fbb_.AddElement(TypeAliases::VT_I64, i64, 0); + } + void add_u64(uint64_t u64) { + fbb_.AddElement(TypeAliases::VT_U64, u64, 0); + } + void add_f32(float f32) { + fbb_.AddElement(TypeAliases::VT_F32, f32, 0.0f); + } + void add_f64(double f64) { + fbb_.AddElement(TypeAliases::VT_F64, f64, 0.0); + } + void add_v8(flatbuffers::Offset> v8) { + fbb_.AddOffset(TypeAliases::VT_V8, v8); + } + void add_vf64(flatbuffers::Offset> vf64) { + fbb_.AddOffset(TypeAliases::VT_VF64, vf64); + } + TypeAliasesBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TypeAliasesBuilder &operator=(const TypeAliasesBuilder &); + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_, 12); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTypeAliases( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + flatbuffers::Offset> v8 = 0, + flatbuffers::Offset> vf64 = 0) { + TypeAliasesBuilder builder_(_fbb); + builder_.add_f64(f64); + builder_.add_u64(u64); + builder_.add_i64(i64); + builder_.add_vf64(vf64); + builder_.add_v8(v8); + builder_.add_f32(f32); + builder_.add_u32(u32); + builder_.add_i32(i32); + builder_.add_u16(u16); + builder_.add_i16(i16); + builder_.add_u8(u8); + builder_.add_i8(i8); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTypeAliasesDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + const std::vector *v8 = nullptr, + const std::vector *vf64 = nullptr) { + return MyGame::Example::CreateTypeAliases( + _fbb, + i8, + u8, + i16, + u16, + i32, + u32, + i64, + u64, + f32, + f64, + v8 ? _fbb.CreateVector(*v8) : 0, + vf64 ? _fbb.CreateVector(*vf64) : 0); +} + +flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + } // namespace Example namespace Example2 { @@ -1263,7 +1518,7 @@ inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolv inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; - { auto _e = pos(); if (_e) _o->pos = std::unique_ptr(new Vec3(*_e)); }; + { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr(new Vec3(*_e)); }; { auto _e = mana(); _o->mana = _e; }; { auto _e = hp(); _o->hp = _e; }; { auto _e = name(); if (_e) _o->name = _e->str(); }; @@ -1273,10 +1528,10 @@ inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function { auto _e = test(); if (_e) _o->test.value = AnyUnion::UnPack(_e, test_type(), _resolver); }; { auto _e = test4(); if (_e) { _o->test4.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test4[_i] = *_e->Get(_i); } } }; { auto _e = testarrayofstring(); if (_e) { _o->testarrayofstring.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring[_i] = _e->Get(_i)->str(); } } }; - { auto _e = testarrayoftables(); if (_e) { _o->testarrayoftables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; - { auto _e = enemy(); if (_e) _o->enemy = std::unique_ptr(_e->UnPack(_resolver)); }; + { auto _e = testarrayoftables(); if (_e) { _o->testarrayoftables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayoftables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } }; + { auto _e = enemy(); if (_e) _o->enemy = flatbuffers::unique_ptr(_e->UnPack(_resolver)); }; { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testnestedflatbuffer[_i] = _e->Get(_i); } } }; - { auto _e = testempty(); if (_e) _o->testempty = std::unique_ptr(_e->UnPack(_resolver)); }; + { auto _e = testempty(); if (_e) _o->testempty = flatbuffers::unique_ptr(_e->UnPack(_resolver)); }; { auto _e = testbool(); _o->testbool = _e; }; { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; }; { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; }; @@ -1376,6 +1631,65 @@ inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder _vector_of_doubles); } +inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = new TypeAliasesT(); + UnPackTo(_o, _resolver); + return _o; +} + +inline void TypeAliases::UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = i8(); _o->i8 = _e; }; + { auto _e = u8(); _o->u8 = _e; }; + { auto _e = i16(); _o->i16 = _e; }; + { auto _e = u16(); _o->u16 = _e; }; + { auto _e = i32(); _o->i32 = _e; }; + { auto _e = u32(); _o->u32 = _e; }; + { auto _e = i64(); _o->i64 = _e; }; + { auto _e = u64(); _o->u64 = _e; }; + { auto _e = f32(); _o->f32 = _e; }; + { auto _e = f64(); _o->f64 = _e; }; + { auto _e = v8(); if (_e) { _o->v8.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->v8[_i] = _e->Get(_i); } } }; + { auto _e = vf64(); if (_e) { _o->vf64.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vf64[_i] = _e->Get(_i); } } }; +} + +inline flatbuffers::Offset TypeAliases::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTypeAliases(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _i8 = _o->i8; + auto _u8 = _o->u8; + auto _i16 = _o->i16; + auto _u16 = _o->u16; + auto _i32 = _o->i32; + auto _u32 = _o->u32; + auto _i64 = _o->i64; + auto _u64 = _o->u64; + auto _f32 = _o->f32; + auto _f64 = _o->f64; + auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0; + auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0; + return MyGame::Example::CreateTypeAliases( + _fbb, + _i8, + _u8, + _i16, + _u16, + _i32, + _u32, + _i64, + _u64, + _f32, + _f64, + _v8, + _vf64); +} + inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) { switch (type) { case Any_NONE: { @@ -1518,10 +1832,10 @@ inline void FinishMonsterBuffer( fbb.Finish(root, MonsterIdentifier()); } -inline std::unique_ptr UnPackMonster( +inline flatbuffers::unique_ptr UnPackMonster( const void *buf, const flatbuffers::resolver_function_t *res = nullptr) { - return std::unique_ptr(GetMonster(buf)->UnPack(res)); + return flatbuffers::unique_ptr(GetMonster(buf)->UnPack(res)); } } // namespace Example diff --git a/tests/monster_test_generated.js b/tests/monster_test_generated.js index 68f47a51b..4899c56e0 100644 --- a/tests/monster_test_generated.js +++ b/tests/monster_test_generated.js @@ -1858,5 +1858,474 @@ MyGame.Example.Monster.finishMonsterBuffer = function(builder, offset) { builder.finish(offset, 'MONS'); }; +/** + * @constructor + */ +MyGame.Example.TypeAliases = function() { + /** + * @type {flatbuffers.ByteBuffer} + */ + this.bb = null; + + /** + * @type {number} + */ + this.bb_pos = 0; +}; + +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {MyGame.Example.TypeAliases} + */ +MyGame.Example.TypeAliases.prototype.__init = function(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {MyGame.Example.TypeAliases=} obj + * @returns {MyGame.Example.TypeAliases} + */ +MyGame.Example.TypeAliases.getRootAsTypeAliases = function(bb, obj) { + return (obj || new MyGame.Example.TypeAliases).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.i8 = function() { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_i8 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.u8 = function() { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_u8 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb.writeUint8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.i16 = function() { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_i16 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.u16 = function() { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_u16 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 10); + + if (offset === 0) { + return false; + } + + this.bb.writeUint16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.i32 = function() { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_i32 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 12); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.u32 = function() { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_u32 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 14); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +MyGame.Example.TypeAliases.prototype.i64 = function() { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_i64 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 16); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +MyGame.Example.TypeAliases.prototype.u64 = function() { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_u64 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 18); + + if (offset === 0) { + return false; + } + + this.bb.writeUint64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.f32 = function() { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_f32 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 20); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.f64 = function() { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +MyGame.Example.TypeAliases.prototype.mutate_f64 = function(value) { + var offset = this.bb.__offset(this.bb_pos, 22); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat64(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {number} index + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.v8 = function(index) { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.v8Length = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Int8Array} + */ +MyGame.Example.TypeAliases.prototype.v8Array = function() { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.vf64 = function(index) { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0; +}; + +/** + * @returns {number} + */ +MyGame.Example.TypeAliases.prototype.vf64Length = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Float64Array} + */ +MyGame.Example.TypeAliases.prototype.vf64Array = function() { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +MyGame.Example.TypeAliases.startTypeAliases = function(builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} i8 + */ +MyGame.Example.TypeAliases.addI8 = function(builder, i8) { + builder.addFieldInt8(0, i8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} u8 + */ +MyGame.Example.TypeAliases.addU8 = function(builder, u8) { + builder.addFieldInt8(1, u8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} i16 + */ +MyGame.Example.TypeAliases.addI16 = function(builder, i16) { + builder.addFieldInt16(2, i16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} u16 + */ +MyGame.Example.TypeAliases.addU16 = function(builder, u16) { + builder.addFieldInt16(3, u16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} i32 + */ +MyGame.Example.TypeAliases.addI32 = function(builder, i32) { + builder.addFieldInt32(4, i32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} u32 + */ +MyGame.Example.TypeAliases.addU32 = function(builder, u32) { + builder.addFieldInt32(5, u32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} i64 + */ +MyGame.Example.TypeAliases.addI64 = function(builder, i64) { + builder.addFieldInt64(6, i64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} u64 + */ +MyGame.Example.TypeAliases.addU64 = function(builder, u64) { + builder.addFieldInt64(7, u64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} f32 + */ +MyGame.Example.TypeAliases.addF32 = function(builder, f32) { + builder.addFieldFloat32(8, f32, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} f64 + */ +MyGame.Example.TypeAliases.addF64 = function(builder, f64) { + builder.addFieldFloat64(9, f64, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} v8Offset + */ +MyGame.Example.TypeAliases.addV8 = function(builder, v8Offset) { + builder.addFieldOffset(10, v8Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.TypeAliases.createV8Vector = function(builder, data) { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.TypeAliases.startV8Vector = function(builder, numElems) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} vf64Offset + */ +MyGame.Example.TypeAliases.addVf64 = function(builder, vf64Offset) { + builder.addFieldOffset(11, vf64Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +MyGame.Example.TypeAliases.createVf64Vector = function(builder, data) { + builder.startVector(8, data.length, 8); + for (var i = data.length - 1; i >= 0; i--) { + builder.addFloat64(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +MyGame.Example.TypeAliases.startVf64Vector = function(builder, numElems) { + builder.startVector(8, numElems, 8); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +MyGame.Example.TypeAliases.endTypeAliases = function(builder) { + var offset = builder.endObject(); + return offset; +}; + // Exports for Node.js and RequireJS this.MyGame = MyGame; diff --git a/tests/monster_test_generated.ts b/tests/monster_test_generated.ts index f1d2f6603..b8938e10c 100644 --- a/tests/monster_test_generated.ts +++ b/tests/monster_test_generated.ts @@ -1305,11 +1305,53 @@ test5Length():number { return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; }; +/** + * @param {number} index + * @returns {flatbuffers.Long} + */ +vectorOfLongs(index: number):flatbuffers.Long|null { + var offset = this.bb.__offset(this.bb_pos, 68); + return offset ? this.bb.readInt64(this.bb.__vector(this.bb_pos + offset) + index * 8) : this.bb.createLong(0, 0); +}; + +/** + * @returns {number} + */ +vectorOfLongsLength():number { + var offset = this.bb.__offset(this.bb_pos, 68); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} index + * @returns {number} + */ +vectorOfDoubles(index: number):number|null { + var offset = this.bb.__offset(this.bb_pos, 70); + return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0; +}; + +/** + * @returns {number} + */ +vectorOfDoublesLength():number { + var offset = this.bb.__offset(this.bb_pos, 70); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Float64Array} + */ +vectorOfDoublesArray():Float64Array|null { + var offset = this.bb.__offset(this.bb_pos, 70); + return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + /** * @param {flatbuffers.Builder} builder */ static startMonster(builder:flatbuffers.Builder) { - builder.startObject(32); + builder.startObject(34); }; /** @@ -1731,6 +1773,64 @@ static startTest5Vector(builder:flatbuffers.Builder, numElems:number) { builder.startVector(4, numElems, 2); }; +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} vectorOfLongsOffset + */ +static addVectorOfLongs(builder:flatbuffers.Builder, vectorOfLongsOffset:flatbuffers.Offset) { + builder.addFieldOffset(32, vectorOfLongsOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createVectorOfLongsVector(builder:flatbuffers.Builder, data:flatbuffers.Long[]):flatbuffers.Offset { + builder.startVector(8, data.length, 8); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt64(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startVectorOfLongsVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(8, numElems, 8); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} vectorOfDoublesOffset + */ +static addVectorOfDoubles(builder:flatbuffers.Builder, vectorOfDoublesOffset:flatbuffers.Offset) { + builder.addFieldOffset(33, vectorOfDoublesOffset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createVectorOfDoublesVector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset { + builder.startVector(8, data.length, 8); + for (var i = data.length - 1; i >= 0; i--) { + builder.addFloat64(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startVectorOfDoublesVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(8, numElems, 8); +}; + /** * @param {flatbuffers.Builder} builder * @returns {flatbuffers.Offset} @@ -1751,3 +1851,473 @@ static finishMonsterBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offse } } +/** + * @constructor + */ +export namespace MyGame.Example{ +export class TypeAliases { + /** + * @type {flatbuffers.ByteBuffer} + */ + bb: flatbuffers.ByteBuffer; + + /** + * @type {number} + */ + bb_pos:number = 0; +/** + * @param {number} i + * @param {flatbuffers.ByteBuffer} bb + * @returns {TypeAliases} + */ +__init(i:number, bb:flatbuffers.ByteBuffer):TypeAliases { + this.bb_pos = i; + this.bb = bb; + return this; +}; + +/** + * @param {flatbuffers.ByteBuffer} bb + * @param {TypeAliases=} obj + * @returns {TypeAliases} + */ +static getRootAsTypeAliases(bb:flatbuffers.ByteBuffer, obj?:TypeAliases):TypeAliases { + return (obj || new TypeAliases).__init(bb.readInt32(bb.position()) + bb.position(), bb); +}; + +/** + * @returns {number} + */ +i8():number { + var offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_i8(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb.writeInt8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +u8():number { + var offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_u8(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb.writeUint8(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +i16():number { + var offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_i16(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb.writeInt16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +u16():number { + var offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_u16(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 10); + + if (offset === 0) { + return false; + } + + this.bb.writeUint16(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +i32():number { + var offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_i32(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 12); + + if (offset === 0) { + return false; + } + + this.bb.writeInt32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +u32():number { + var offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_u32(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 14); + + if (offset === 0) { + return false; + } + + this.bb.writeUint32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +i64():flatbuffers.Long { + var offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +mutate_i64(value:flatbuffers.Long):boolean { + var offset = this.bb.__offset(this.bb_pos, 16); + + if (offset === 0) { + return false; + } + + this.bb.writeInt64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {flatbuffers.Long} + */ +u64():flatbuffers.Long { + var offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0); +}; + +/** + * @param {flatbuffers.Long} value + * @returns {boolean} + */ +mutate_u64(value:flatbuffers.Long):boolean { + var offset = this.bb.__offset(this.bb_pos, 18); + + if (offset === 0) { + return false; + } + + this.bb.writeUint64(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +f32():number { + var offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_f32(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 20); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat32(this.bb_pos + offset, value); + return true; +}; + +/** + * @returns {number} + */ +f64():number { + var offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; +}; + +/** + * @param {number} value + * @returns {boolean} + */ +mutate_f64(value:number):boolean { + var offset = this.bb.__offset(this.bb_pos, 22); + + if (offset === 0) { + return false; + } + + this.bb.writeFloat64(this.bb_pos + offset, value); + return true; +}; + +/** + * @param {number} index + * @returns {number} + */ +v8(index: number):number|null { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readInt8(this.bb.__vector(this.bb_pos + offset) + index) : 0; +}; + +/** + * @returns {number} + */ +v8Length():number { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Int8Array} + */ +v8Array():Int8Array|null { + var offset = this.bb.__offset(this.bb_pos, 24); + return offset ? new Int8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {number} index + * @returns {number} + */ +vf64(index: number):number|null { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readFloat64(this.bb.__vector(this.bb_pos + offset) + index * 8) : 0; +}; + +/** + * @returns {number} + */ +vf64Length():number { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0; +}; + +/** + * @returns {Float64Array} + */ +vf64Array():Float64Array|null { + var offset = this.bb.__offset(this.bb_pos, 26); + return offset ? new Float64Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null; +}; + +/** + * @param {flatbuffers.Builder} builder + */ +static startTypeAliases(builder:flatbuffers.Builder) { + builder.startObject(12); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} i8 + */ +static addI8(builder:flatbuffers.Builder, i8:number) { + builder.addFieldInt8(0, i8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} u8 + */ +static addU8(builder:flatbuffers.Builder, u8:number) { + builder.addFieldInt8(1, u8, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} i16 + */ +static addI16(builder:flatbuffers.Builder, i16:number) { + builder.addFieldInt16(2, i16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} u16 + */ +static addU16(builder:flatbuffers.Builder, u16:number) { + builder.addFieldInt16(3, u16, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} i32 + */ +static addI32(builder:flatbuffers.Builder, i32:number) { + builder.addFieldInt32(4, i32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} u32 + */ +static addU32(builder:flatbuffers.Builder, u32:number) { + builder.addFieldInt32(5, u32, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} i64 + */ +static addI64(builder:flatbuffers.Builder, i64:flatbuffers.Long) { + builder.addFieldInt64(6, i64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Long} u64 + */ +static addU64(builder:flatbuffers.Builder, u64:flatbuffers.Long) { + builder.addFieldInt64(7, u64, builder.createLong(0, 0)); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} f32 + */ +static addF32(builder:flatbuffers.Builder, f32:number) { + builder.addFieldFloat32(8, f32, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} f64 + */ +static addF64(builder:flatbuffers.Builder, f64:number) { + builder.addFieldFloat64(9, f64, 0.0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} v8Offset + */ +static addV8(builder:flatbuffers.Builder, v8Offset:flatbuffers.Offset) { + builder.addFieldOffset(10, v8Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createV8Vector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (var i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startV8Vector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {flatbuffers.Offset} vf64Offset + */ +static addVf64(builder:flatbuffers.Builder, vf64Offset:flatbuffers.Offset) { + builder.addFieldOffset(11, vf64Offset, 0); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {Array.} data + * @returns {flatbuffers.Offset} + */ +static createVf64Vector(builder:flatbuffers.Builder, data:number[] | Uint8Array):flatbuffers.Offset { + builder.startVector(8, data.length, 8); + for (var i = data.length - 1; i >= 0; i--) { + builder.addFloat64(data[i]); + } + return builder.endVector(); +}; + +/** + * @param {flatbuffers.Builder} builder + * @param {number} numElems + */ +static startVf64Vector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(8, numElems, 8); +}; + +/** + * @param {flatbuffers.Builder} builder + * @returns {flatbuffers.Offset} + */ +static endTypeAliases(builder:flatbuffers.Builder):flatbuffers.Offset { + var offset = builder.endObject(); + return offset; +}; + +} +} diff --git a/tests/namespace_test/namespace_test2_generated.ts b/tests/namespace_test/namespace_test2_generated.ts index 8deae09c4..daaaab3cf 100644 --- a/tests/namespace_test/namespace_test2_generated.ts +++ b/tests/namespace_test/namespace_test2_generated.ts @@ -1,6 +1,6 @@ // automatically generated by the FlatBuffers compiler, do not modify -import * as NS9459827973991502386 from "./namespace_test1_generated"; +import * as NS4989953370203581498 from "./namespace_test1_generated"; /** * @constructor */ @@ -39,24 +39,24 @@ static getRootAsTableInFirstNS(bb:flatbuffers.ByteBuffer, obj?:TableInFirstNS):T * @param {NamespaceA.NamespaceB.TableInNestedNS=} obj * @returns {NamespaceA.NamespaceB.TableInNestedNS|null} */ -fooTable(obj?:NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS|null { +fooTable(obj?:NS4989953370203581498.NamespaceA.NamespaceB.TableInNestedNS):NS4989953370203581498.NamespaceA.NamespaceB.TableInNestedNS|null { var offset = this.bb.__offset(this.bb_pos, 4); - return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; + return offset ? (obj || new NS4989953370203581498.NamespaceA.NamespaceB.TableInNestedNS).__init(this.bb.__indirect(this.bb_pos + offset), this.bb) : null; }; /** * @returns {NamespaceA.NamespaceB.EnumInNestedNS} */ -fooEnum():NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS { +fooEnum():NS4989953370203581498.NamespaceA.NamespaceB.EnumInNestedNS { var offset = this.bb.__offset(this.bb_pos, 6); - return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb.readInt8(this.bb_pos + offset)) : NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A; + return offset ? /** @type {NamespaceA.NamespaceB.EnumInNestedNS} */ (this.bb.readInt8(this.bb_pos + offset)) : NS4989953370203581498.NamespaceA.NamespaceB.EnumInNestedNS.A; }; /** * @param {NamespaceA.NamespaceB.EnumInNestedNS} value * @returns {boolean} */ -mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS):boolean { +mutate_foo_enum(value:NS4989953370203581498.NamespaceA.NamespaceB.EnumInNestedNS):boolean { var offset = this.bb.__offset(this.bb_pos, 6); if (offset === 0) { @@ -71,9 +71,9 @@ mutate_foo_enum(value:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS * @param {NamespaceA.NamespaceB.StructInNestedNS=} obj * @returns {NamespaceA.NamespaceB.StructInNestedNS|null} */ -fooStruct(obj?:NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS):NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS|null { +fooStruct(obj?:NS4989953370203581498.NamespaceA.NamespaceB.StructInNestedNS):NS4989953370203581498.NamespaceA.NamespaceB.StructInNestedNS|null { var offset = this.bb.__offset(this.bb_pos, 8); - return offset ? (obj || new NS9459827973991502386.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb) : null; + return offset ? (obj || new NS4989953370203581498.NamespaceA.NamespaceB.StructInNestedNS).__init(this.bb_pos + offset, this.bb) : null; }; /** @@ -95,8 +95,8 @@ static addFooTable(builder:flatbuffers.Builder, fooTableOffset:flatbuffers.Offse * @param {flatbuffers.Builder} builder * @param {NamespaceA.NamespaceB.EnumInNestedNS} fooEnum */ -static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS) { - builder.addFieldInt8(1, fooEnum, NS9459827973991502386.NamespaceA.NamespaceB.EnumInNestedNS.A); +static addFooEnum(builder:flatbuffers.Builder, fooEnum:NS4989953370203581498.NamespaceA.NamespaceB.EnumInNestedNS) { + builder.addFieldInt8(1, fooEnum, NS4989953370203581498.NamespaceA.NamespaceB.EnumInNestedNS.A); }; /** diff --git a/tests/test.cpp b/tests/test.cpp index 23996fb3b..90d8a7c07 100644 --- a/tests/test.cpp +++ b/tests/test.cpp @@ -1691,6 +1691,39 @@ void FlexBuffersTest() { TEST_EQ_STR(jsontest, jsonback.c_str()); } +void TypeAliasesTest() +{ + flatbuffers::FlatBufferBuilder builder; + + builder.Finish(CreateTypeAliases(builder, + INT8_MIN, UINT8_MAX, INT16_MIN, UINT16_MAX, + INT32_MIN, UINT32_MAX, INT64_MIN, UINT64_MAX, 2.3f, 2.3)); + + auto p = builder.GetBufferPointer(); + auto ta = flatbuffers::GetRoot(p); + + TEST_EQ(ta->i8(), INT8_MIN); + TEST_EQ(ta->u8(), UINT8_MAX); + TEST_EQ(ta->i16(), INT16_MIN); + TEST_EQ(ta->u16(), UINT16_MAX); + TEST_EQ(ta->i32(), INT32_MIN); + TEST_EQ(ta->u32(), UINT32_MAX); + TEST_EQ(ta->i64(), INT64_MIN); + TEST_EQ(ta->u64(), UINT64_MAX); + TEST_EQ(ta->f32(), 2.3f); + TEST_EQ(ta->f64(), 2.3); + TEST_EQ(sizeof(ta->i8()), 1); + TEST_EQ(sizeof(ta->i16()), 2); + TEST_EQ(sizeof(ta->i32()), 4); + TEST_EQ(sizeof(ta->i64()), 8); + TEST_EQ(sizeof(ta->u8()), 1); + TEST_EQ(sizeof(ta->u16()), 2); + TEST_EQ(sizeof(ta->u32()), 4); + TEST_EQ(sizeof(ta->u64()), 8); + TEST_EQ(sizeof(ta->f32()), 4); + TEST_EQ(sizeof(ta->f64()), 8); +} + int main(int /*argc*/, const char * /*argv*/[]) { // Run our various test suites: @@ -1740,6 +1773,7 @@ int main(int /*argc*/, const char * /*argv*/[]) { ParseUnionTest(); ConformTest(); ParseProtoBufAsciiTest(); + TypeAliasesTest(); FlexBuffersTest();