Add scalar type aliases for int8, uint8, ..., f32, f64 (#4400)
* Add type aliases
* Add generated code
* Rebase master
diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h
index 386c38d..cd37b9c 100644
--- a/include/flatbuffers/idl.h
+++ b/include/flatbuffers/idl.h
@@ -40,28 +40,29 @@
// 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<void>, int, int, StringOffset, int) \
- TD(VECTOR, "", Offset<void>, int, int, VectorOffset, int) \
- TD(STRUCT, "", Offset<void>, int, int, int, int) \
- TD(UNION, "", Offset<void>, int, int, int, int)
+ TD(STRING, "string", "", Offset<void>, int, int, StringOffset, int) \
+ TD(VECTOR, "", "", Offset<void>, int, int, VectorOffset, int) \
+ TD(STRUCT, "", "", Offset<void>, int, int, int, int) \
+ TD(UNION, "", "", Offset<void>, 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 @@
/*
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 @@
__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 56d10e6..22a6e22 100644
--- a/src/idl_gen_cpp.cpp
+++ b/src/idl_gen_cpp.cpp
@@ -302,7 +302,7 @@
// 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 5c8586d..30a097d 100644
--- a/src/idl_gen_general.cpp
+++ b/src/idl_gen_general.cpp
@@ -241,14 +241,16 @@
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 4cdbf03..8d4a7a5 100644
--- a/src/idl_gen_go.cpp
+++ b/src/idl_gen_go.cpp
@@ -694,7 +694,8 @@
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 7266551..8021f92 100644
--- a/src/idl_gen_php.cpp
+++ b/src/idl_gen_php.cpp
@@ -879,7 +879,8 @@
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 257515b..acfcf0b 100644
--- a/src/idl_gen_python.cpp
+++ b/src/idl_gen_python.cpp
@@ -580,7 +580,8 @@
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 e27d664..b7c5875 100644
--- a/src/idl_gen_text.cpp
+++ b/src/idl_gen_text.cpp
@@ -135,8 +135,8 @@
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<CTYPE>( \
*reinterpret_cast<const Vector<CTYPE> *>(val), \
@@ -226,8 +226,8 @@
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<CTYPE>(fd, table, struct_def.fixed, \
opts, indent + Indent(opts), _text)) { \
@@ -237,8 +237,8 @@
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 fff35aa..b835631 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 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 @@
#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 @@
#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 @@
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 @@
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 @@
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 @@
// 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 0000000..f03c142
--- /dev/null
+++ b/tests/MyGame/Example/TypeAliases.cs
@@ -0,0 +1,102 @@
+// <auto-generated>
+// automatically generated by the FlatBuffers compiler, do not modify
+// </auto-generated>
+
+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<byte>? 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<byte>? 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<TypeAliases> 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<TypeAliases> EndTypeAliases(FlatBufferBuilder builder) {
+ int o = builder.EndObject();
+ return new Offset<TypeAliases>(o);
+ }
+};
+
+
+}
diff --git a/tests/MyGame/Example/TypeAliases.go b/tests/MyGame/Example/TypeAliases.go
new file mode 100644
index 0000000..c64c287
--- /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 0000000..a5cff0c
--- /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 0000000..ecf804d
--- /dev/null
+++ b/tests/MyGame/Example/TypeAliases.php
@@ -0,0 +1,387 @@
+<?php
+// automatically generated by the FlatBuffers compiler, do not modify
+
+namespace MyGame\Example;
+
+use \Google\FlatBuffers\Struct;
+use \Google\FlatBuffers\Table;
+use \Google\FlatBuffers\ByteBuffer;
+use \Google\FlatBuffers\FlatBufferBuilder;
+
+class TypeAliases extends Table
+{
+ /**
+ * @param ByteBuffer $bb
+ * @return TypeAliases
+ */
+ public static function getRootAsTypeAliases(ByteBuffer $bb)
+ {
+ $obj = new TypeAliases();
+ return ($obj->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 0000000..707e53f
--- /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 e94b801..fc20d89 100644
--- a/tests/monster_test.bfbs
+++ b/tests/monster_test.bfbs
Binary files differ
diff --git a/tests/monster_test.fbs b/tests/monster_test.fbs
index a199e90..41cacef 100755
--- a/tests/monster_test.fbs
+++ b/tests/monster_test.fbs
@@ -79,6 +79,21 @@
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 43675fa..9af53bb 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 0206e55..b105f5a 100644
--- a/tests/monster_test_generated.h
+++ b/tests/monster_test_generated.h
@@ -32,6 +32,9 @@
struct Monster;
struct MonsterT;
+struct TypeAliases;
+struct TypeAliasesT;
+
enum Color {
Color_Red = 1,
Color_Green = 2,
@@ -518,7 +521,7 @@
struct MonsterT : public flatbuffers::NativeTable {
typedef Monster TableType;
- std::unique_ptr<Vec3> pos;
+ flatbuffers::unique_ptr<Vec3> pos;
int16_t mana;
int16_t hp;
std::string name;
@@ -527,10 +530,10 @@
AnyUnion test;
std::vector<Test> test4;
std::vector<std::string> testarrayofstring;
- std::vector<std::unique_ptr<MonsterT>> testarrayoftables;
- std::unique_ptr<MonsterT> enemy;
+ std::vector<flatbuffers::unique_ptr<MonsterT>> testarrayoftables;
+ flatbuffers::unique_ptr<MonsterT> enemy;
std::vector<uint8_t> testnestedflatbuffer;
- std::unique_ptr<StatT> testempty;
+ flatbuffers::unique_ptr<StatT> testempty;
bool testbool;
int32_t testhashs32_fnv1;
uint32_t testhashu32_fnv1;
@@ -1165,6 +1168,258 @@
flatbuffers::Offset<Monster> 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<int8_t> v8;
+ std::vector<double> 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<int8_t>(VT_I8, 0);
+ }
+ bool mutate_i8(int8_t _i8) {
+ return SetField<int8_t>(VT_I8, _i8, 0);
+ }
+ uint8_t u8() const {
+ return GetField<uint8_t>(VT_U8, 0);
+ }
+ bool mutate_u8(uint8_t _u8) {
+ return SetField<uint8_t>(VT_U8, _u8, 0);
+ }
+ int16_t i16() const {
+ return GetField<int16_t>(VT_I16, 0);
+ }
+ bool mutate_i16(int16_t _i16) {
+ return SetField<int16_t>(VT_I16, _i16, 0);
+ }
+ uint16_t u16() const {
+ return GetField<uint16_t>(VT_U16, 0);
+ }
+ bool mutate_u16(uint16_t _u16) {
+ return SetField<uint16_t>(VT_U16, _u16, 0);
+ }
+ int32_t i32() const {
+ return GetField<int32_t>(VT_I32, 0);
+ }
+ bool mutate_i32(int32_t _i32) {
+ return SetField<int32_t>(VT_I32, _i32, 0);
+ }
+ uint32_t u32() const {
+ return GetField<uint32_t>(VT_U32, 0);
+ }
+ bool mutate_u32(uint32_t _u32) {
+ return SetField<uint32_t>(VT_U32, _u32, 0);
+ }
+ int64_t i64() const {
+ return GetField<int64_t>(VT_I64, 0);
+ }
+ bool mutate_i64(int64_t _i64) {
+ return SetField<int64_t>(VT_I64, _i64, 0);
+ }
+ uint64_t u64() const {
+ return GetField<uint64_t>(VT_U64, 0);
+ }
+ bool mutate_u64(uint64_t _u64) {
+ return SetField<uint64_t>(VT_U64, _u64, 0);
+ }
+ float f32() const {
+ return GetField<float>(VT_F32, 0.0f);
+ }
+ bool mutate_f32(float _f32) {
+ return SetField<float>(VT_F32, _f32, 0.0f);
+ }
+ double f64() const {
+ return GetField<double>(VT_F64, 0.0);
+ }
+ bool mutate_f64(double _f64) {
+ return SetField<double>(VT_F64, _f64, 0.0);
+ }
+ const flatbuffers::Vector<int8_t> *v8() const {
+ return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_V8);
+ }
+ flatbuffers::Vector<int8_t> *mutable_v8() {
+ return GetPointer<flatbuffers::Vector<int8_t> *>(VT_V8);
+ }
+ const flatbuffers::Vector<double> *vf64() const {
+ return GetPointer<const flatbuffers::Vector<double> *>(VT_VF64);
+ }
+ flatbuffers::Vector<double> *mutable_vf64() {
+ return GetPointer<flatbuffers::Vector<double> *>(VT_VF64);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int8_t>(verifier, VT_I8) &&
+ VerifyField<uint8_t>(verifier, VT_U8) &&
+ VerifyField<int16_t>(verifier, VT_I16) &&
+ VerifyField<uint16_t>(verifier, VT_U16) &&
+ VerifyField<int32_t>(verifier, VT_I32) &&
+ VerifyField<uint32_t>(verifier, VT_U32) &&
+ VerifyField<int64_t>(verifier, VT_I64) &&
+ VerifyField<uint64_t>(verifier, VT_U64) &&
+ VerifyField<float>(verifier, VT_F32) &&
+ VerifyField<double>(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<TypeAliases> 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<int8_t>(TypeAliases::VT_I8, i8, 0);
+ }
+ void add_u8(uint8_t u8) {
+ fbb_.AddElement<uint8_t>(TypeAliases::VT_U8, u8, 0);
+ }
+ void add_i16(int16_t i16) {
+ fbb_.AddElement<int16_t>(TypeAliases::VT_I16, i16, 0);
+ }
+ void add_u16(uint16_t u16) {
+ fbb_.AddElement<uint16_t>(TypeAliases::VT_U16, u16, 0);
+ }
+ void add_i32(int32_t i32) {
+ fbb_.AddElement<int32_t>(TypeAliases::VT_I32, i32, 0);
+ }
+ void add_u32(uint32_t u32) {
+ fbb_.AddElement<uint32_t>(TypeAliases::VT_U32, u32, 0);
+ }
+ void add_i64(int64_t i64) {
+ fbb_.AddElement<int64_t>(TypeAliases::VT_I64, i64, 0);
+ }
+ void add_u64(uint64_t u64) {
+ fbb_.AddElement<uint64_t>(TypeAliases::VT_U64, u64, 0);
+ }
+ void add_f32(float f32) {
+ fbb_.AddElement<float>(TypeAliases::VT_F32, f32, 0.0f);
+ }
+ void add_f64(double f64) {
+ fbb_.AddElement<double>(TypeAliases::VT_F64, f64, 0.0);
+ }
+ void add_v8(flatbuffers::Offset<flatbuffers::Vector<int8_t>> v8) {
+ fbb_.AddOffset(TypeAliases::VT_V8, v8);
+ }
+ void add_vf64(flatbuffers::Offset<flatbuffers::Vector<double>> vf64) {
+ fbb_.AddOffset(TypeAliases::VT_VF64, vf64);
+ }
+ TypeAliasesBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ TypeAliasesBuilder &operator=(const TypeAliasesBuilder &);
+ flatbuffers::Offset<TypeAliases> Finish() {
+ const auto end = fbb_.EndTable(start_, 12);
+ auto o = flatbuffers::Offset<TypeAliases>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<TypeAliases> 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<flatbuffers::Vector<int8_t>> v8 = 0,
+ flatbuffers::Offset<flatbuffers::Vector<double>> 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<TypeAliases> 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<int8_t> *v8 = nullptr,
+ const std::vector<double> *vf64 = nullptr) {
+ return MyGame::Example::CreateTypeAliases(
+ _fbb,
+ i8,
+ u8,
+ i16,
+ u16,
+ i32,
+ u32,
+ i64,
+ u64,
+ f32,
+ f64,
+ v8 ? _fbb.CreateVector<int8_t>(*v8) : 0,
+ vf64 ? _fbb.CreateVector<double>(*vf64) : 0);
+}
+
+flatbuffers::Offset<TypeAliases> CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
} // namespace Example
namespace Example2 {
@@ -1263,7 +1518,7 @@
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<Vec3>(new Vec3(*_e)); };
+ { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr<Vec3>(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 @@
{ 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<MonsterT>(_e->Get(_i)->UnPack(_resolver)); } } };
- { auto _e = enemy(); if (_e) _o->enemy = std::unique_ptr<MonsterT>(_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<MonsterT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = enemy(); if (_e) _o->enemy = flatbuffers::unique_ptr<MonsterT>(_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<StatT>(_e->UnPack(_resolver)); };
+ { auto _e = testempty(); if (_e) _o->testempty = flatbuffers::unique_ptr<StatT>(_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 @@
_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> TypeAliases::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateTypeAliases(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<TypeAliases> 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 @@
fbb.Finish(root, MonsterIdentifier());
}
-inline std::unique_ptr<MonsterT> UnPackMonster(
+inline flatbuffers::unique_ptr<MonsterT> UnPackMonster(
const void *buf,
const flatbuffers::resolver_function_t *res = nullptr) {
- return std::unique_ptr<MonsterT>(GetMonster(buf)->UnPack(res));
+ return flatbuffers::unique_ptr<MonsterT>(GetMonster(buf)->UnPack(res));
}
} // namespace Example
diff --git a/tests/monster_test_generated.js b/tests/monster_test_generated.js
index 68f47a5..4899c56 100644
--- a/tests/monster_test_generated.js
+++ b/tests/monster_test_generated.js
@@ -1858,5 +1858,474 @@
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.<number>} 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.<number>} 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 f1d2f66..b8938e1 100644
--- a/tests/monster_test_generated.ts
+++ b/tests/monster_test_generated.ts
@@ -1306,10 +1306,52 @@
};
/**
+ * @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);
};
/**
@@ -1733,6 +1775,64 @@
/**
* @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.<flatbuffers.Long>} 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.<number>} 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}
*/
static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
@@ -1751,3 +1851,473 @@
}
}
+/**
+ * @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.<number>} 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.<number>} 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 8deae09..daaaab3 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 @@
* @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 @@
* @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 @@
* @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 23996fb..90d8a7c 100644
--- a/tests/test.cpp
+++ b/tests/test.cpp
@@ -1691,6 +1691,39 @@
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<TypeAliases>(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 @@
ParseUnionTest();
ConformTest();
ParseProtoBufAsciiTest();
+ TypeAliasesTest();
FlexBuffersTest();