Convert aos over to flatbuffers
Everything builds, and all the tests pass. I suspect that some entries
are missing from the config files, but those will be found pretty
quickly on startup.
There is no logging or live introspection of queue messages.
Change-Id: I496ee01ed68f202c7851bed7e8786cee30df29f5
diff --git a/third_party/flatbuffers/BUILD b/third_party/flatbuffers/BUILD
index 17f5b8c..67a3a14 100644
--- a/third_party/flatbuffers/BUILD
+++ b/third_party/flatbuffers/BUILD
@@ -1,5 +1,7 @@
licenses(["notice"])
+load("@//tools:environments.bzl", "mcu_cpus")
+
package(
default_visibility = ["//visibility:public"],
features = [
@@ -100,6 +102,9 @@
"src/idl_gen_text.cpp",
"src/util.cpp",
],
+ data = [
+ "reflection/reflection.fbs",
+ ],
includes = [
"grpc/",
"include/",
@@ -118,6 +123,7 @@
"include/flatbuffers/stl_emulation.h",
"include/flatbuffers/util.h",
],
+ compatible_with = mcu_cpus,
includes = ["include/"],
linkstatic = 1,
)
diff --git a/third_party/flatbuffers/build_defs.bzl b/third_party/flatbuffers/build_defs.bzl
index a92f0ed..743c666 100644
--- a/third_party/flatbuffers/build_defs.bzl
+++ b/third_party/flatbuffers/build_defs.bzl
@@ -11,15 +11,18 @@
"./",
"$(GENDIR)",
"$(BINDIR)",
+ "$(execpath @com_github_google_flatbuffers//:flatc).runfiles/com_github_google_flatbuffers",
]
DEFAULT_FLATC_ARGS = [
"--gen-object-api",
"--gen-compare",
- "--no-includes",
+ "--keep-prefix",
"--gen-mutable",
"--reflect-names",
"--cpp-ptr-type flatbuffers::unique_ptr",
+ "--force-empty",
+ "--gen-name-strings",
]
def flatbuffer_library_public(
@@ -33,6 +36,7 @@
flatc_args = DEFAULT_FLATC_ARGS,
reflection_name = "",
reflection_visibility = None,
+ compatible_with = None,
output_to_bindir = False):
"""Generates code files for reading/writing the given flatbuffers in the requested language using the public compiler.
@@ -83,6 +87,7 @@
tools = [flatc_path],
cmd = genrule_cmd,
message = "Generating flatbuffer files for %s:" % (name),
+ compatible_with = compatible_with,
)
if reflection_name:
reflection_genrule_cmd = " ".join([
@@ -109,20 +114,20 @@
tools = [flatc_path],
cmd = reflection_genrule_cmd,
message = "Generating flatbuffer reflection binary for %s:" % (name),
+ compatible_with = compatible_with,
)
- native.Fileset(
- name = reflection_name,
- out = "%s_out" % reflection_name,
- entries = [
- native.FilesetEntry(files = reflection_outs),
- ],
+ native.filegroup(
+ name = "%s_out" % reflection_name,
+ srcs = reflection_outs,
visibility = reflection_visibility,
+ compatible_with = compatible_with,
)
def flatbuffer_cc_library(
name,
srcs,
srcs_filegroup_name = "",
+ compatible_with = None,
out_prefix = "",
includes = [],
include_paths = DEFAULT_INCLUDE_PATHS,
@@ -208,6 +213,7 @@
flatc_args = flatc_args,
reflection_name = reflection_name,
reflection_visibility = visibility,
+ compatible_with = compatible_with,
)
native.cc_library(
name = name,
@@ -226,6 +232,7 @@
includes = [],
linkstatic = 1,
visibility = visibility,
+ compatible_with = compatible_with,
)
# A filegroup for the `srcs`. That is, all the schema files for this
@@ -234,4 +241,5 @@
name = srcs_filegroup_name if srcs_filegroup_name else "%s_includes" % (name),
srcs = srcs,
visibility = srcs_filegroup_visibility if srcs_filegroup_visibility != None else visibility,
+ compatible_with = compatible_with,
)
diff --git a/third_party/flatbuffers/include/flatbuffers/reflection_generated.h b/third_party/flatbuffers/include/flatbuffers/reflection_generated.h
index 0e73a0f..e80b0c9 100644
--- a/third_party/flatbuffers/include/flatbuffers/reflection_generated.h
+++ b/third_party/flatbuffers/include/flatbuffers/reflection_generated.h
@@ -9,22 +9,58 @@
namespace reflection {
struct Type;
+struct TypeBuilder;
+struct TypeT;
struct KeyValue;
+struct KeyValueBuilder;
+struct KeyValueT;
struct EnumVal;
+struct EnumValBuilder;
+struct EnumValT;
struct Enum;
+struct EnumBuilder;
+struct EnumT;
struct Field;
+struct FieldBuilder;
+struct FieldT;
struct Object;
+struct ObjectBuilder;
+struct ObjectT;
struct RPCCall;
+struct RPCCallBuilder;
+struct RPCCallT;
struct Service;
+struct ServiceBuilder;
+struct ServiceT;
struct Schema;
+struct SchemaBuilder;
+struct SchemaT;
+
+inline const flatbuffers::TypeTable *TypeTypeTable();
+
+inline const flatbuffers::TypeTable *KeyValueTypeTable();
+
+inline const flatbuffers::TypeTable *EnumValTypeTable();
+
+inline const flatbuffers::TypeTable *EnumTypeTable();
+
+inline const flatbuffers::TypeTable *FieldTypeTable();
+
+inline const flatbuffers::TypeTable *ObjectTypeTable();
+
+inline const flatbuffers::TypeTable *RPCCallTypeTable();
+
+inline const flatbuffers::TypeTable *ServiceTypeTable();
+
+inline const flatbuffers::TypeTable *SchemaTypeTable();
enum BaseType {
None = 0,
@@ -102,7 +138,26 @@
return EnumNamesBaseType()[index];
}
+struct TypeT : public flatbuffers::NativeTable {
+ typedef Type TableType;
+ reflection::BaseType base_type;
+ reflection::BaseType element;
+ int32_t index;
+ uint16_t fixed_length;
+ TypeT()
+ : base_type(reflection::None),
+ element(reflection::None),
+ index(-1),
+ fixed_length(0) {
+ }
+};
+
struct Type FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef TypeT NativeTableType;
+ typedef TypeBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return TypeTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_BASE_TYPE = 4,
VT_ELEMENT = 6,
@@ -129,9 +184,13 @@
VerifyField<uint16_t>(verifier, VT_FIXED_LENGTH) &&
verifier.EndTable();
}
+ TypeT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(TypeT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<Type> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct TypeBuilder {
+ typedef Type Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_base_type(reflection::BaseType base_type) {
@@ -172,7 +231,22 @@
return builder_.Finish();
}
+flatbuffers::Offset<Type> CreateType(flatbuffers::FlatBufferBuilder &_fbb, const TypeT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct KeyValueT : public flatbuffers::NativeTable {
+ typedef KeyValue TableType;
+ std::string key;
+ std::string value;
+ KeyValueT() {
+ }
+};
+
struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef KeyValueT NativeTableType;
+ typedef KeyValueBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return KeyValueTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_KEY = 4,
VT_VALUE = 6
@@ -197,9 +271,13 @@
verifier.VerifyString(value()) &&
verifier.EndTable();
}
+ KeyValueT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(KeyValueT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<KeyValue> Pack(flatbuffers::FlatBufferBuilder &_fbb, const KeyValueT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct KeyValueBuilder {
+ typedef KeyValue Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_key(flatbuffers::Offset<flatbuffers::String> key) {
@@ -243,7 +321,26 @@
value__);
}
+flatbuffers::Offset<KeyValue> CreateKeyValue(flatbuffers::FlatBufferBuilder &_fbb, const KeyValueT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EnumValT : public flatbuffers::NativeTable {
+ typedef EnumVal TableType;
+ std::string name;
+ int64_t value;
+ std::unique_ptr<reflection::ObjectT> object;
+ std::unique_ptr<reflection::TypeT> union_type;
+ std::vector<std::string> documentation;
+ EnumValT()
+ : value(0) {
+ }
+};
+
struct EnumVal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EnumValT NativeTableType;
+ typedef EnumValBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return EnumValTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_VALUE = 6,
@@ -286,9 +383,13 @@
verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable();
}
+ EnumValT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EnumValT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<EnumVal> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EnumValT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct EnumValBuilder {
+ typedef EnumVal Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
@@ -353,7 +454,27 @@
documentation__);
}
+flatbuffers::Offset<EnumVal> CreateEnumVal(flatbuffers::FlatBufferBuilder &_fbb, const EnumValT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct EnumT : public flatbuffers::NativeTable {
+ typedef Enum TableType;
+ std::string name;
+ std::vector<std::unique_ptr<reflection::EnumValT>> values;
+ bool is_union;
+ std::unique_ptr<reflection::TypeT> underlying_type;
+ std::vector<std::unique_ptr<reflection::KeyValueT>> attributes;
+ std::vector<std::string> documentation;
+ EnumT()
+ : is_union(false) {
+ }
+};
+
struct Enum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef EnumT NativeTableType;
+ typedef EnumBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return EnumTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_VALUES = 6,
@@ -404,9 +525,13 @@
verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable();
}
+ EnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(EnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<Enum> Pack(flatbuffers::FlatBufferBuilder &_fbb, const EnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct EnumBuilder {
+ typedef Enum Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
@@ -482,7 +607,38 @@
documentation__);
}
+flatbuffers::Offset<Enum> CreateEnum(flatbuffers::FlatBufferBuilder &_fbb, const EnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct FieldT : public flatbuffers::NativeTable {
+ typedef Field TableType;
+ std::string name;
+ std::unique_ptr<reflection::TypeT> type;
+ uint16_t id;
+ uint16_t offset;
+ int64_t default_integer;
+ double default_real;
+ bool deprecated;
+ bool required;
+ bool key;
+ std::vector<std::unique_ptr<reflection::KeyValueT>> attributes;
+ std::vector<std::string> documentation;
+ FieldT()
+ : id(0),
+ offset(0),
+ default_integer(0),
+ default_real(0.0),
+ deprecated(false),
+ required(false),
+ key(false) {
+ }
+};
+
struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef FieldT NativeTableType;
+ typedef FieldBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return FieldTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_TYPE = 6,
@@ -556,9 +712,13 @@
verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable();
}
+ FieldT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(FieldT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<Field> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FieldT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FieldBuilder {
+ typedef Field Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
@@ -667,7 +827,30 @@
documentation__);
}
+flatbuffers::Offset<Field> CreateField(flatbuffers::FlatBufferBuilder &_fbb, const FieldT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct ObjectT : public flatbuffers::NativeTable {
+ typedef Object TableType;
+ std::string name;
+ std::vector<std::unique_ptr<reflection::FieldT>> fields;
+ bool is_struct;
+ int32_t minalign;
+ int32_t bytesize;
+ std::vector<std::unique_ptr<reflection::KeyValueT>> attributes;
+ std::vector<std::string> documentation;
+ ObjectT()
+ : is_struct(false),
+ minalign(0),
+ bytesize(0) {
+ }
+};
+
struct Object FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef ObjectT NativeTableType;
+ typedef ObjectBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return ObjectTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_FIELDS = 6,
@@ -722,9 +905,13 @@
verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable();
}
+ ObjectT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(ObjectT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<Object> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ObjectT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ObjectBuilder {
+ typedef Object Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
@@ -806,7 +993,25 @@
documentation__);
}
+flatbuffers::Offset<Object> CreateObject(flatbuffers::FlatBufferBuilder &_fbb, const ObjectT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct RPCCallT : public flatbuffers::NativeTable {
+ typedef RPCCall TableType;
+ std::string name;
+ std::unique_ptr<reflection::ObjectT> request;
+ std::unique_ptr<reflection::ObjectT> response;
+ std::vector<std::unique_ptr<reflection::KeyValueT>> attributes;
+ std::vector<std::string> documentation;
+ RPCCallT() {
+ }
+};
+
struct RPCCall FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef RPCCallT NativeTableType;
+ typedef RPCCallBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return RPCCallTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_REQUEST = 6,
@@ -851,9 +1056,13 @@
verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable();
}
+ RPCCallT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(RPCCallT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<RPCCall> Pack(flatbuffers::FlatBufferBuilder &_fbb, const RPCCallT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct RPCCallBuilder {
+ typedef RPCCall Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
@@ -921,7 +1130,24 @@
documentation__);
}
+flatbuffers::Offset<RPCCall> CreateRPCCall(flatbuffers::FlatBufferBuilder &_fbb, const RPCCallT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct ServiceT : public flatbuffers::NativeTable {
+ typedef Service TableType;
+ std::string name;
+ std::vector<std::unique_ptr<reflection::RPCCallT>> calls;
+ std::vector<std::unique_ptr<reflection::KeyValueT>> attributes;
+ std::vector<std::string> documentation;
+ ServiceT() {
+ }
+};
+
struct Service FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef ServiceT NativeTableType;
+ typedef ServiceBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return ServiceTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_NAME = 4,
VT_CALLS = 6,
@@ -961,9 +1187,13 @@
verifier.VerifyVectorOfStrings(documentation()) &&
verifier.EndTable();
}
+ ServiceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(ServiceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<Service> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ServiceBuilder {
+ typedef Service Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_name(flatbuffers::Offset<flatbuffers::String> name) {
@@ -1023,7 +1253,26 @@
documentation__);
}
+flatbuffers::Offset<Service> CreateService(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct SchemaT : public flatbuffers::NativeTable {
+ typedef Schema TableType;
+ std::vector<std::unique_ptr<reflection::ObjectT>> objects;
+ std::vector<std::unique_ptr<reflection::EnumT>> enums;
+ std::string file_ident;
+ std::string file_ext;
+ std::unique_ptr<reflection::ObjectT> root_table;
+ std::vector<std::unique_ptr<reflection::ServiceT>> services;
+ SchemaT() {
+ }
+};
+
struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+ typedef SchemaT NativeTableType;
+ typedef SchemaBuilder Builder;
+ static const flatbuffers::TypeTable *MiniReflectTypeTable() {
+ return SchemaTypeTable();
+ }
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_OBJECTS = 4,
VT_ENUMS = 6,
@@ -1069,9 +1318,13 @@
verifier.VerifyVectorOfTables(services()) &&
verifier.EndTable();
}
+ SchemaT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ void UnPackTo(SchemaT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
+ static flatbuffers::Offset<Schema> Pack(flatbuffers::FlatBufferBuilder &_fbb, const SchemaT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct SchemaBuilder {
+ typedef Schema Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<reflection::Object>>> objects) {
@@ -1147,6 +1400,647 @@
services__);
}
+flatbuffers::Offset<Schema> CreateSchema(flatbuffers::FlatBufferBuilder &_fbb, const SchemaT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+inline TypeT *Type::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new TypeT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void Type::UnPackTo(TypeT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = base_type(); _o->base_type = _e; };
+ { auto _e = element(); _o->element = _e; };
+ { auto _e = index(); _o->index = _e; };
+ { auto _e = fixed_length(); _o->fixed_length = _e; };
+}
+
+inline flatbuffers::Offset<Type> Type::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateType(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Type> CreateType(flatbuffers::FlatBufferBuilder &_fbb, const TypeT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TypeT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _base_type = _o->base_type;
+ auto _element = _o->element;
+ auto _index = _o->index;
+ auto _fixed_length = _o->fixed_length;
+ return reflection::CreateType(
+ _fbb,
+ _base_type,
+ _element,
+ _index,
+ _fixed_length);
+}
+
+inline KeyValueT *KeyValue::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new KeyValueT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void KeyValue::UnPackTo(KeyValueT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = key(); if (_e) _o->key = _e->str(); };
+ { auto _e = value(); if (_e) _o->value = _e->str(); };
+}
+
+inline flatbuffers::Offset<KeyValue> KeyValue::Pack(flatbuffers::FlatBufferBuilder &_fbb, const KeyValueT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateKeyValue(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<KeyValue> CreateKeyValue(flatbuffers::FlatBufferBuilder &_fbb, const KeyValueT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const KeyValueT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _key = _fbb.CreateString(_o->key);
+ auto _value = _o->value.empty() ? 0 : _fbb.CreateString(_o->value);
+ return reflection::CreateKeyValue(
+ _fbb,
+ _key,
+ _value);
+}
+
+inline EnumValT *EnumVal::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new EnumValT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void EnumVal::UnPackTo(EnumValT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = name(); if (_e) _o->name = _e->str(); };
+ { auto _e = value(); _o->value = _e; };
+ { auto _e = object(); if (_e) _o->object = std::unique_ptr<reflection::ObjectT>(_e->UnPack(_resolver)); };
+ { auto _e = union_type(); if (_e) _o->union_type = std::unique_ptr<reflection::TypeT>(_e->UnPack(_resolver)); };
+ { auto _e = documentation(); if (_e) { _o->documentation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->documentation[_i] = _e->Get(_i)->str(); } } };
+}
+
+inline flatbuffers::Offset<EnumVal> EnumVal::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EnumValT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEnumVal(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<EnumVal> CreateEnumVal(flatbuffers::FlatBufferBuilder &_fbb, const EnumValT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EnumValT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _name = _fbb.CreateString(_o->name);
+ auto _value = _o->value;
+ auto _object = _o->object ? CreateObject(_fbb, _o->object.get(), _rehasher) : 0;
+ auto _union_type = _o->union_type ? CreateType(_fbb, _o->union_type.get(), _rehasher) : 0;
+ auto _documentation = _o->documentation.size() ? _fbb.CreateVectorOfStrings(_o->documentation) : 0;
+ return reflection::CreateEnumVal(
+ _fbb,
+ _name,
+ _value,
+ _object,
+ _union_type,
+ _documentation);
+}
+
+inline EnumT *Enum::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new EnumT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void Enum::UnPackTo(EnumT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = name(); if (_e) _o->name = _e->str(); };
+ { auto _e = values(); if (_e) { _o->values.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->values[_i] = std::unique_ptr<reflection::EnumValT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = is_union(); _o->is_union = _e; };
+ { auto _e = underlying_type(); if (_e) _o->underlying_type = std::unique_ptr<reflection::TypeT>(_e->UnPack(_resolver)); };
+ { auto _e = attributes(); if (_e) { _o->attributes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->attributes[_i] = std::unique_ptr<reflection::KeyValueT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = documentation(); if (_e) { _o->documentation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->documentation[_i] = _e->Get(_i)->str(); } } };
+}
+
+inline flatbuffers::Offset<Enum> Enum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const EnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateEnum(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Enum> CreateEnum(flatbuffers::FlatBufferBuilder &_fbb, const EnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const EnumT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _name = _fbb.CreateString(_o->name);
+ auto _values = _fbb.CreateVector<flatbuffers::Offset<reflection::EnumVal>> (_o->values.size(), [](size_t i, _VectorArgs *__va) { return CreateEnumVal(*__va->__fbb, __va->__o->values[i].get(), __va->__rehasher); }, &_va );
+ auto _is_union = _o->is_union;
+ auto _underlying_type = _o->underlying_type ? CreateType(_fbb, _o->underlying_type.get(), _rehasher) : 0;
+ auto _attributes = _o->attributes.size() ? _fbb.CreateVector<flatbuffers::Offset<reflection::KeyValue>> (_o->attributes.size(), [](size_t i, _VectorArgs *__va) { return CreateKeyValue(*__va->__fbb, __va->__o->attributes[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _documentation = _o->documentation.size() ? _fbb.CreateVectorOfStrings(_o->documentation) : 0;
+ return reflection::CreateEnum(
+ _fbb,
+ _name,
+ _values,
+ _is_union,
+ _underlying_type,
+ _attributes,
+ _documentation);
+}
+
+inline FieldT *Field::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new FieldT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void Field::UnPackTo(FieldT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = name(); if (_e) _o->name = _e->str(); };
+ { auto _e = type(); if (_e) _o->type = std::unique_ptr<reflection::TypeT>(_e->UnPack(_resolver)); };
+ { auto _e = id(); _o->id = _e; };
+ { auto _e = offset(); _o->offset = _e; };
+ { auto _e = default_integer(); _o->default_integer = _e; };
+ { auto _e = default_real(); _o->default_real = _e; };
+ { auto _e = deprecated(); _o->deprecated = _e; };
+ { auto _e = required(); _o->required = _e; };
+ { auto _e = key(); _o->key = _e; };
+ { auto _e = attributes(); if (_e) { _o->attributes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->attributes[_i] = std::unique_ptr<reflection::KeyValueT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = documentation(); if (_e) { _o->documentation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->documentation[_i] = _e->Get(_i)->str(); } } };
+}
+
+inline flatbuffers::Offset<Field> Field::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FieldT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateField(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Field> CreateField(flatbuffers::FlatBufferBuilder &_fbb, const FieldT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FieldT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _name = _fbb.CreateString(_o->name);
+ auto _type = _o->type ? CreateType(_fbb, _o->type.get(), _rehasher) : 0;
+ auto _id = _o->id;
+ auto _offset = _o->offset;
+ auto _default_integer = _o->default_integer;
+ auto _default_real = _o->default_real;
+ auto _deprecated = _o->deprecated;
+ auto _required = _o->required;
+ auto _key = _o->key;
+ auto _attributes = _o->attributes.size() ? _fbb.CreateVector<flatbuffers::Offset<reflection::KeyValue>> (_o->attributes.size(), [](size_t i, _VectorArgs *__va) { return CreateKeyValue(*__va->__fbb, __va->__o->attributes[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _documentation = _o->documentation.size() ? _fbb.CreateVectorOfStrings(_o->documentation) : 0;
+ return reflection::CreateField(
+ _fbb,
+ _name,
+ _type,
+ _id,
+ _offset,
+ _default_integer,
+ _default_real,
+ _deprecated,
+ _required,
+ _key,
+ _attributes,
+ _documentation);
+}
+
+inline ObjectT *Object::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new ObjectT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void Object::UnPackTo(ObjectT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = name(); if (_e) _o->name = _e->str(); };
+ { auto _e = fields(); if (_e) { _o->fields.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->fields[_i] = std::unique_ptr<reflection::FieldT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = is_struct(); _o->is_struct = _e; };
+ { auto _e = minalign(); _o->minalign = _e; };
+ { auto _e = bytesize(); _o->bytesize = _e; };
+ { auto _e = attributes(); if (_e) { _o->attributes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->attributes[_i] = std::unique_ptr<reflection::KeyValueT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = documentation(); if (_e) { _o->documentation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->documentation[_i] = _e->Get(_i)->str(); } } };
+}
+
+inline flatbuffers::Offset<Object> Object::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ObjectT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateObject(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Object> CreateObject(flatbuffers::FlatBufferBuilder &_fbb, const ObjectT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ObjectT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _name = _fbb.CreateString(_o->name);
+ auto _fields = _fbb.CreateVector<flatbuffers::Offset<reflection::Field>> (_o->fields.size(), [](size_t i, _VectorArgs *__va) { return CreateField(*__va->__fbb, __va->__o->fields[i].get(), __va->__rehasher); }, &_va );
+ auto _is_struct = _o->is_struct;
+ auto _minalign = _o->minalign;
+ auto _bytesize = _o->bytesize;
+ auto _attributes = _o->attributes.size() ? _fbb.CreateVector<flatbuffers::Offset<reflection::KeyValue>> (_o->attributes.size(), [](size_t i, _VectorArgs *__va) { return CreateKeyValue(*__va->__fbb, __va->__o->attributes[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _documentation = _o->documentation.size() ? _fbb.CreateVectorOfStrings(_o->documentation) : 0;
+ return reflection::CreateObject(
+ _fbb,
+ _name,
+ _fields,
+ _is_struct,
+ _minalign,
+ _bytesize,
+ _attributes,
+ _documentation);
+}
+
+inline RPCCallT *RPCCall::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new RPCCallT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void RPCCall::UnPackTo(RPCCallT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = name(); if (_e) _o->name = _e->str(); };
+ { auto _e = request(); if (_e) _o->request = std::unique_ptr<reflection::ObjectT>(_e->UnPack(_resolver)); };
+ { auto _e = response(); if (_e) _o->response = std::unique_ptr<reflection::ObjectT>(_e->UnPack(_resolver)); };
+ { auto _e = attributes(); if (_e) { _o->attributes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->attributes[_i] = std::unique_ptr<reflection::KeyValueT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = documentation(); if (_e) { _o->documentation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->documentation[_i] = _e->Get(_i)->str(); } } };
+}
+
+inline flatbuffers::Offset<RPCCall> RPCCall::Pack(flatbuffers::FlatBufferBuilder &_fbb, const RPCCallT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateRPCCall(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<RPCCall> CreateRPCCall(flatbuffers::FlatBufferBuilder &_fbb, const RPCCallT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const RPCCallT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _name = _fbb.CreateString(_o->name);
+ auto _request = _o->request ? CreateObject(_fbb, _o->request.get(), _rehasher) : 0;
+ auto _response = _o->response ? CreateObject(_fbb, _o->response.get(), _rehasher) : 0;
+ auto _attributes = _o->attributes.size() ? _fbb.CreateVector<flatbuffers::Offset<reflection::KeyValue>> (_o->attributes.size(), [](size_t i, _VectorArgs *__va) { return CreateKeyValue(*__va->__fbb, __va->__o->attributes[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _documentation = _o->documentation.size() ? _fbb.CreateVectorOfStrings(_o->documentation) : 0;
+ return reflection::CreateRPCCall(
+ _fbb,
+ _name,
+ _request,
+ _response,
+ _attributes,
+ _documentation);
+}
+
+inline ServiceT *Service::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new ServiceT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void Service::UnPackTo(ServiceT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = name(); if (_e) _o->name = _e->str(); };
+ { auto _e = calls(); if (_e) { _o->calls.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->calls[_i] = std::unique_ptr<reflection::RPCCallT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = attributes(); if (_e) { _o->attributes.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->attributes[_i] = std::unique_ptr<reflection::KeyValueT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = documentation(); if (_e) { _o->documentation.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->documentation[_i] = _e->Get(_i)->str(); } } };
+}
+
+inline flatbuffers::Offset<Service> Service::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateService(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Service> CreateService(flatbuffers::FlatBufferBuilder &_fbb, const ServiceT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ServiceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _name = _fbb.CreateString(_o->name);
+ auto _calls = _o->calls.size() ? _fbb.CreateVector<flatbuffers::Offset<reflection::RPCCall>> (_o->calls.size(), [](size_t i, _VectorArgs *__va) { return CreateRPCCall(*__va->__fbb, __va->__o->calls[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _attributes = _o->attributes.size() ? _fbb.CreateVector<flatbuffers::Offset<reflection::KeyValue>> (_o->attributes.size(), [](size_t i, _VectorArgs *__va) { return CreateKeyValue(*__va->__fbb, __va->__o->attributes[i].get(), __va->__rehasher); }, &_va ) : 0;
+ auto _documentation = _o->documentation.size() ? _fbb.CreateVectorOfStrings(_o->documentation) : 0;
+ return reflection::CreateService(
+ _fbb,
+ _name,
+ _calls,
+ _attributes,
+ _documentation);
+}
+
+inline SchemaT *Schema::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
+ auto _o = new SchemaT();
+ UnPackTo(_o, _resolver);
+ return _o;
+}
+
+inline void Schema::UnPackTo(SchemaT *_o, const flatbuffers::resolver_function_t *_resolver) const {
+ (void)_o;
+ (void)_resolver;
+ { auto _e = objects(); if (_e) { _o->objects.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->objects[_i] = std::unique_ptr<reflection::ObjectT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = enums(); if (_e) { _o->enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->enums[_i] = std::unique_ptr<reflection::EnumT>(_e->Get(_i)->UnPack(_resolver)); } } };
+ { auto _e = file_ident(); if (_e) _o->file_ident = _e->str(); };
+ { auto _e = file_ext(); if (_e) _o->file_ext = _e->str(); };
+ { auto _e = root_table(); if (_e) _o->root_table = std::unique_ptr<reflection::ObjectT>(_e->UnPack(_resolver)); };
+ { auto _e = services(); if (_e) { _o->services.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->services[_i] = std::unique_ptr<reflection::ServiceT>(_e->Get(_i)->UnPack(_resolver)); } } };
+}
+
+inline flatbuffers::Offset<Schema> Schema::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SchemaT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateSchema(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<Schema> CreateSchema(flatbuffers::FlatBufferBuilder &_fbb, const SchemaT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
+ (void)_rehasher;
+ (void)_o;
+ struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SchemaT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
+ auto _objects = _fbb.CreateVector<flatbuffers::Offset<reflection::Object>> (_o->objects.size(), [](size_t i, _VectorArgs *__va) { return CreateObject(*__va->__fbb, __va->__o->objects[i].get(), __va->__rehasher); }, &_va );
+ auto _enums = _fbb.CreateVector<flatbuffers::Offset<reflection::Enum>> (_o->enums.size(), [](size_t i, _VectorArgs *__va) { return CreateEnum(*__va->__fbb, __va->__o->enums[i].get(), __va->__rehasher); }, &_va );
+ auto _file_ident = _o->file_ident.empty() ? 0 : _fbb.CreateString(_o->file_ident);
+ auto _file_ext = _o->file_ext.empty() ? 0 : _fbb.CreateString(_o->file_ext);
+ auto _root_table = _o->root_table ? CreateObject(_fbb, _o->root_table.get(), _rehasher) : 0;
+ auto _services = _o->services.size() ? _fbb.CreateVector<flatbuffers::Offset<reflection::Service>> (_o->services.size(), [](size_t i, _VectorArgs *__va) { return CreateService(*__va->__fbb, __va->__o->services[i].get(), __va->__rehasher); }, &_va ) : 0;
+ return reflection::CreateSchema(
+ _fbb,
+ _objects,
+ _enums,
+ _file_ident,
+ _file_ext,
+ _root_table,
+ _services);
+}
+
+inline const flatbuffers::TypeTable *BaseTypeTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::BaseTypeTypeTable
+ };
+ static const char * const names[] = {
+ "None",
+ "UType",
+ "Bool",
+ "Byte",
+ "UByte",
+ "Short",
+ "UShort",
+ "Int",
+ "UInt",
+ "Long",
+ "ULong",
+ "Float",
+ "Double",
+ "String",
+ "Vector",
+ "Obj",
+ "Union",
+ "Array"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_ENUM, 18, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *TypeTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_CHAR, 0, 0 },
+ { flatbuffers::ET_INT, 0, -1 },
+ { flatbuffers::ET_USHORT, 0, -1 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::BaseTypeTypeTable
+ };
+ static const char * const names[] = {
+ "base_type",
+ "element",
+ "index",
+ "fixed_length"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *KeyValueTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_STRING, 0, -1 }
+ };
+ static const char * const names[] = {
+ "key",
+ "value"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 2, type_codes, nullptr, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *EnumValTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_LONG, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 0, 0 },
+ { flatbuffers::ET_SEQUENCE, 0, 1 },
+ { flatbuffers::ET_STRING, 1, -1 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::ObjectTypeTable,
+ reflection::TypeTypeTable
+ };
+ static const char * const names[] = {
+ "name",
+ "value",
+ "object",
+ "union_type",
+ "documentation"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *EnumTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 1, 0 },
+ { flatbuffers::ET_BOOL, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 0, 1 },
+ { flatbuffers::ET_SEQUENCE, 1, 2 },
+ { flatbuffers::ET_STRING, 1, -1 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::EnumValTypeTable,
+ reflection::TypeTypeTable,
+ reflection::KeyValueTypeTable
+ };
+ static const char * const names[] = {
+ "name",
+ "values",
+ "is_union",
+ "underlying_type",
+ "attributes",
+ "documentation"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *FieldTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 0, 0 },
+ { flatbuffers::ET_USHORT, 0, -1 },
+ { flatbuffers::ET_USHORT, 0, -1 },
+ { flatbuffers::ET_LONG, 0, -1 },
+ { flatbuffers::ET_DOUBLE, 0, -1 },
+ { flatbuffers::ET_BOOL, 0, -1 },
+ { flatbuffers::ET_BOOL, 0, -1 },
+ { flatbuffers::ET_BOOL, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 1, 1 },
+ { flatbuffers::ET_STRING, 1, -1 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::TypeTypeTable,
+ reflection::KeyValueTypeTable
+ };
+ static const char * const names[] = {
+ "name",
+ "type",
+ "id",
+ "offset",
+ "default_integer",
+ "default_real",
+ "deprecated",
+ "required",
+ "key",
+ "attributes",
+ "documentation"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 11, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *ObjectTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 1, 0 },
+ { flatbuffers::ET_BOOL, 0, -1 },
+ { flatbuffers::ET_INT, 0, -1 },
+ { flatbuffers::ET_INT, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 1, 1 },
+ { flatbuffers::ET_STRING, 1, -1 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::FieldTypeTable,
+ reflection::KeyValueTypeTable
+ };
+ static const char * const names[] = {
+ "name",
+ "fields",
+ "is_struct",
+ "minalign",
+ "bytesize",
+ "attributes",
+ "documentation"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 7, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *RPCCallTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 0, 0 },
+ { flatbuffers::ET_SEQUENCE, 0, 0 },
+ { flatbuffers::ET_SEQUENCE, 1, 1 },
+ { flatbuffers::ET_STRING, 1, -1 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::ObjectTypeTable,
+ reflection::KeyValueTypeTable
+ };
+ static const char * const names[] = {
+ "name",
+ "request",
+ "response",
+ "attributes",
+ "documentation"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *ServiceTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 1, 0 },
+ { flatbuffers::ET_SEQUENCE, 1, 1 },
+ { flatbuffers::ET_STRING, 1, -1 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::RPCCallTypeTable,
+ reflection::KeyValueTypeTable
+ };
+ static const char * const names[] = {
+ "name",
+ "calls",
+ "attributes",
+ "documentation"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
+inline const flatbuffers::TypeTable *SchemaTypeTable() {
+ static const flatbuffers::TypeCode type_codes[] = {
+ { flatbuffers::ET_SEQUENCE, 1, 0 },
+ { flatbuffers::ET_SEQUENCE, 1, 1 },
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_STRING, 0, -1 },
+ { flatbuffers::ET_SEQUENCE, 0, 0 },
+ { flatbuffers::ET_SEQUENCE, 1, 2 }
+ };
+ static const flatbuffers::TypeFunction type_refs[] = {
+ reflection::ObjectTypeTable,
+ reflection::EnumTypeTable,
+ reflection::ServiceTypeTable
+ };
+ static const char * const names[] = {
+ "objects",
+ "enums",
+ "file_ident",
+ "file_ext",
+ "root_table",
+ "services"
+ };
+ static const flatbuffers::TypeTable tt = {
+ flatbuffers::ST_TABLE, 6, type_codes, type_refs, nullptr, names
+ };
+ return &tt;
+}
+
inline const reflection::Schema *GetSchema(const void *buf) {
return flatbuffers::GetRoot<reflection::Schema>(buf);
}
@@ -1190,6 +2084,18 @@
fbb.FinishSizePrefixed(root, SchemaIdentifier());
}
+inline std::unique_ptr<reflection::SchemaT> UnPackSchema(
+ const void *buf,
+ const flatbuffers::resolver_function_t *res = nullptr) {
+ return std::unique_ptr<reflection::SchemaT>(GetSchema(buf)->UnPack(res));
+}
+
+inline std::unique_ptr<reflection::SchemaT> UnPackSizePrefixedSchema(
+ const void *buf,
+ const flatbuffers::resolver_function_t *res = nullptr) {
+ return std::unique_ptr<reflection::SchemaT>(GetSizePrefixedSchema(buf)->UnPack(res));
+}
+
} // namespace reflection
#endif // FLATBUFFERS_GENERATED_REFLECTION_REFLECTION_H_
diff --git a/third_party/flatbuffers/reflection/generate_code.sh b/third_party/flatbuffers/reflection/generate_code.sh
index f186b73..6e12c3d 100755
--- a/third_party/flatbuffers/reflection/generate_code.sh
+++ b/third_party/flatbuffers/reflection/generate_code.sh
@@ -15,4 +15,4 @@
# limitations under the License.
set -e
-../flatc -c --no-prefix -o ../include/flatbuffers reflection.fbs
+../../../bazel-out/host/bin/external/com_github_google_flatbuffers/flatc -c --gen-object-api --reflect-names --no-prefix -o ../include/flatbuffers reflection.fbs
diff --git a/third_party/flatbuffers/src/idl_gen_cpp.cpp b/third_party/flatbuffers/src/idl_gen_cpp.cpp
index 0f9950d..a646d91 100644
--- a/third_party/flatbuffers/src/idl_gen_cpp.cpp
+++ b/third_party/flatbuffers/src/idl_gen_cpp.cpp
@@ -196,9 +196,19 @@
auto noext = flatbuffers::StripExtension(it->second);
auto basename = flatbuffers::StripPath(noext);
- code_ += "#include \"" + parser_.opts.include_prefix +
- (parser_.opts.keep_include_path ? noext : basename) +
- "_generated.h\"";
+ // TODO(austin): Clean this up.
+ // The reflection_generated.h header is not in the reflection folder like
+ // it's include path and namespace suggests. Detect this special case and
+ // rewrite it.
+ std::string include =
+ parser_.opts.include_prefix +
+ (parser_.opts.keep_include_path ? noext : basename) + "_generated.h";
+
+ if (include == "reflection/reflection_generated.h") {
+ include = "flatbuffers/reflection_generated.h";
+ }
+
+ code_ += "#include \"" + include + "\"";
num_includes++;
}
if (num_includes) code_ += "";
@@ -251,12 +261,14 @@
// Generate forward declarations for all structs/tables, since they may
// have circular references.
+ // LOCAL_MOD: Add builders to forward declares
for (auto it = parser_.structs_.vec.begin();
it != parser_.structs_.vec.end(); ++it) {
const auto &struct_def = **it;
if (!struct_def.generated) {
SetNameSpace(struct_def.defined_namespace);
code_ += "struct " + Name(struct_def) + ";";
+ code_ += "struct " + Name(struct_def) + "Builder;";
if (parser_.opts.generate_object_based_api) {
auto nativeName =
NativeName(Name(struct_def), &struct_def, parser_.opts);
@@ -1803,6 +1815,8 @@
if (parser_.opts.generate_object_based_api) {
code_ += " typedef {{NATIVE_NAME}} NativeTableType;";
}
+ // LOCAL_MOD: Add builder typedef.
+ code_ += " typedef {{STRUCT_NAME}}Builder Builder;";
if (parser_.opts.mini_reflect != IDLOptions::kNone) {
code_ +=
" static const flatbuffers::TypeTable *MiniReflectTypeTable() {";
@@ -2065,6 +2079,7 @@
// Generate a builder struct:
code_ += "struct {{STRUCT_NAME}}Builder {";
+ code_ += " typedef {{STRUCT_NAME}} Table;";
code_ += " flatbuffers::FlatBufferBuilder &fbb_;";
code_ += " flatbuffers::uoffset_t start_;";