From 97e89c5acd89e77742d3a8e2458d2dc90321d80b Mon Sep 17 00:00:00 2001 From: Aman Priyadarshi Date: Sat, 6 Aug 2022 06:11:45 +0100 Subject: [PATCH] grpc/compiler: Respect filename suffix and extension during code generation (#7343) * grpc/compiler: Respect filename suffix and extension during code generation grpc compiler is not respecting filename suffix and extension passed to flatc CLI. This causes compiler to spit out incorrect code, which then cannot be compiled without modification. Following patch fixes the problem. Note, I ended up removing some code introduced #6954 ("Have grpc include file with correct filename-suffix given to flatc") in favour of keeping sanity of the generator code. Signed-off-by: Aman Priyadarshi * tests: Add filename-suffix and filename-ext test files * Test 1: Filename extension changed to "hpp". * Test 2: Filename suffix changed to "_suffix". * Test 3: Filename extension changed to "hpp" and suffix changed to "_suffix" Signed-off-by: Aman Priyadarshi --- grpc/src/compiler/cpp_generator.cc | 16 +- grpc/src/compiler/cpp_generator.h | 2 + grpc/src/compiler/schema_interface.h | 2 - scripts/generate_code.py | 22 +- src/idl_gen_grpc.cpp | 13 +- .../ext_only/monster_test.grpc.fb.cc | 131 + .../ext_only/monster_test.grpc.fb.h | 350 ++ .../ext_only/monster_test_generated.hpp | 4041 +++++++++++++++++ .../filesuffix_only/monster_test.grpc.fb.cc | 131 + .../filesuffix_only/monster_test.grpc.fb.h | 350 ++ .../filesuffix_only/monster_test_suffix.h | 4041 +++++++++++++++++ .../monster_test.grpc.fb.cc | 131 + .../monster_test.grpc.fb.h | 350 ++ .../monster_test_suffix.hpp | 4041 +++++++++++++++++ 14 files changed, 13596 insertions(+), 25 deletions(-) create mode 100644 tests/monster_test_suffix/ext_only/monster_test.grpc.fb.cc create mode 100644 tests/monster_test_suffix/ext_only/monster_test.grpc.fb.h create mode 100644 tests/monster_test_suffix/ext_only/monster_test_generated.hpp create mode 100644 tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.cc create mode 100644 tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.h create mode 100644 tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h create mode 100644 tests/monster_test_suffix/monster_test.grpc.fb.cc create mode 100644 tests/monster_test_suffix/monster_test.grpc.fb.h create mode 100644 tests/monster_test_suffix/monster_test_suffix.hpp diff --git a/grpc/src/compiler/cpp_generator.cc b/grpc/src/compiler/cpp_generator.cc index 59dcc66d2..16e3373b2 100644 --- a/grpc/src/compiler/cpp_generator.cc +++ b/grpc/src/compiler/cpp_generator.cc @@ -8,7 +8,6 @@ namespace grpc_cpp_generator { namespace { -grpc::string message_header_ext() { return "_generated.h"; } grpc::string service_header_ext() { return ".grpc.fb.h"; } template grpc::string as_string(T x) { @@ -65,7 +64,7 @@ void PrintIncludes(grpc_generator::Printer *printer, } grpc::string GetHeaderPrologue(grpc_generator::File *file, - const Parameters & /*params*/) { + const Parameters ¶ms) { grpc::string output; { // Scope the output stream so it closes and finalizes output to the string. @@ -75,7 +74,7 @@ grpc::string GetHeaderPrologue(grpc_generator::File *file, vars["filename"] = file->filename(); vars["filename_identifier"] = FilenameIdentifier(file->filename()); vars["filename_base"] = file->filename_without_ext(); - vars["message_header_ext"] = file->message_header_ext(); + vars["message_header_ext"] = params.message_header_extension; printer->Print(vars, "// Generated by the gRPC C++ plugin.\n"); printer->Print(vars, @@ -1118,7 +1117,7 @@ grpc::string GetHeaderEpilogue(grpc_generator::File *file, } grpc::string GetSourcePrologue(grpc_generator::File *file, - const Parameters & /*params*/) { + const Parameters ¶ms) { grpc::string output; { // Scope the output stream so it closes and finalizes output to the string. @@ -1127,8 +1126,8 @@ grpc::string GetSourcePrologue(grpc_generator::File *file, vars["filename"] = file->filename(); vars["filename_base"] = file->filename_without_ext(); - vars["message_header_ext"] = file->message_header_ext(); - vars["service_header_ext"] = file->service_header_ext(); + vars["message_header_ext"] = params.message_header_extension; + vars["service_header_ext"] = service_header_ext(); printer->Print(vars, "// Generated by the gRPC C++ plugin.\n"); printer->Print(vars, @@ -1532,9 +1531,8 @@ grpc::string GetSourceEpilogue(grpc_generator::File *file, return temp; } -// TODO(mmukhi): Make sure we need parameters or not. grpc::string GetMockPrologue(grpc_generator::File *file, - const Parameters & /*params*/) { + const Parameters ¶ms) { grpc::string output; { // Scope the output stream so it closes and finalizes output to the string. @@ -1543,7 +1541,7 @@ grpc::string GetMockPrologue(grpc_generator::File *file, vars["filename"] = file->filename(); vars["filename_base"] = file->filename_without_ext(); - vars["message_header_ext"] = message_header_ext(); + vars["message_header_ext"] = params.message_header_extension; vars["service_header_ext"] = service_header_ext(); printer->Print(vars, "// Generated by the gRPC C++ plugin.\n"); diff --git a/grpc/src/compiler/cpp_generator.h b/grpc/src/compiler/cpp_generator.h index 16aa97ac6..a9af1a679 100644 --- a/grpc/src/compiler/cpp_generator.h +++ b/grpc/src/compiler/cpp_generator.h @@ -33,6 +33,8 @@ struct Parameters { grpc::string grpc_search_path; // Generate GMOCK code to facilitate unit testing. bool generate_mock_code; + // By default, use "_generated.h" + std::string message_header_extension; }; // Return the prologue of the generated header file. diff --git a/grpc/src/compiler/schema_interface.h b/grpc/src/compiler/schema_interface.h index e42e3e349..f89288d75 100644 --- a/grpc/src/compiler/schema_interface.h +++ b/grpc/src/compiler/schema_interface.h @@ -107,8 +107,6 @@ struct File : public CommentHolder { virtual grpc::string package() const = 0; virtual std::vector package_parts() const = 0; virtual grpc::string additional_headers() const = 0; - virtual std::string message_header_ext() const = 0; - virtual std::string service_header_ext() const = 0; virtual int service_count() const = 0; virtual std::unique_ptr service(int i) const = 0; diff --git a/scripts/generate_code.py b/scripts/generate_code.py index f5df98e5a..01d65df78 100755 --- a/scripts/generate_code.py +++ b/scripts/generate_code.py @@ -425,17 +425,23 @@ flatc( # --filename-suffix and --filename-ext tests flatc( - CPP_OPTS + NO_INCL_OPTS + ["--filename-suffix", "_suffix", "--filename-ext", "hpp"], + CPP_OPTS + NO_INCL_OPTS + ["--grpc", "--filename-ext", "hpp"], include="include_test", + prefix="monster_test_suffix/ext_only", + schema="monster_test.fbs", +) +flatc( + CPP_OPTS + NO_INCL_OPTS + ["--grpc", "--filename-suffix", "_suffix"], + include="include_test", + prefix="monster_test_suffix/filesuffix_only", + schema="monster_test.fbs", +) +flatc( + CPP_OPTS + NO_INCL_OPTS + ["--grpc", "--filename-suffix", "_suffix", "--filename-ext", "hpp"], + include="include_test", + prefix="monster_test_suffix", schema="monster_test.fbs", ) -orig_monster_file = Path(tests_path, "monster_test_generated.h") -new_monster_file = Path(tests_path, "monster_test_suffix.hpp") -assert new_monster_file.exists(), "filename suffix option did not produce a file" -assert filecmp.cmp( - str(orig_monster_file), str(new_monster_file) -), "filename suffix option did not produce identical results" -new_monster_file.unlink() # Flag c++17 requires Clang6, GCC7, MSVC2017 (_MSC_VER >= 1914) or higher. cpp_17_prefix = "cpp17/generated_cpp17" diff --git a/src/idl_gen_grpc.cpp b/src/idl_gen_grpc.cpp index 6894ffb0d..2be24e71a 100644 --- a/src/idl_gen_grpc.cpp +++ b/src/idl_gen_grpc.cpp @@ -242,12 +242,6 @@ class FlatBufFile : public grpc_generator::File { return StripExtension(file_name_); } - std::string message_header_ext() const { - return parser_.opts.filename_suffix + ".h"; - } - - std::string service_header_ext() const { return ".grpc.fb.h"; } - std::string package() const { return parser_.current_namespace_->GetFullyQualifiedName(""); } @@ -347,6 +341,7 @@ bool GenerateGoGRPC(const Parser &parser, const std::string &path, bool GenerateCppGRPC(const Parser &parser, const std::string &path, const std::string &file_name) { + const auto &opts = parser.opts; int nservices = 0; for (auto it = parser.services_.vec.begin(); it != parser.services_.vec.end(); ++it) { @@ -354,9 +349,15 @@ bool GenerateCppGRPC(const Parser &parser, const std::string &path, } if (!nservices) return true; + std::string suffix = ""; + suffix += opts.filename_suffix.empty() ? "_generated" : opts.filename_suffix; + suffix += "."; + suffix += opts.filename_extension.empty() ? "h" : opts.filename_extension; + grpc_cpp_generator::Parameters generator_parameters; // TODO(wvo): make the other parameters in this struct configurable. generator_parameters.use_system_headers = true; + generator_parameters.message_header_extension = suffix; FlatBufFile fbfile(parser, file_name, FlatBufFile::kLanguageCpp); diff --git a/tests/monster_test_suffix/ext_only/monster_test.grpc.fb.cc b/tests/monster_test_suffix/ext_only/monster_test.grpc.fb.cc new file mode 100644 index 000000000..3cc72ed63 --- /dev/null +++ b/tests/monster_test_suffix/ext_only/monster_test.grpc.fb.cc @@ -0,0 +1,131 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: monster_test + +#include "monster_test_generated.hpp" +#include "monster_test.grpc.fb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +namespace MyGame { +namespace Example { + +static const char* MonsterStorage_method_names[] = { + "/MyGame.Example.MonsterStorage/Store", + "/MyGame.Example.MonsterStorage/Retrieve", + "/MyGame.Example.MonsterStorage/GetMaxHitPoint", + "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints", +}; + +std::unique_ptr< MonsterStorage::Stub> MonsterStorage::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& /*options*/) { + std::unique_ptr< MonsterStorage::Stub> stub(new MonsterStorage::Stub(channel)); + return stub; +} + +MonsterStorage::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) + : channel_(channel) , rpcmethod_Store_(MonsterStorage_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Retrieve_(MonsterStorage_method_names[1], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + , rpcmethod_GetMaxHitPoint_(MonsterStorage_method_names[2], ::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) + , rpcmethod_GetMinMaxHitPoints_(MonsterStorage_method_names[3], ::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + {} + +::grpc::Status MonsterStorage::Stub::Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Store_, context, request, response); +} + +::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, false); +} + +::grpc::ClientReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return ::grpc::internal::ClientReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_Retrieve_, context, request); +} + +::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, false, nullptr); +} + +::grpc::ClientWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return ::grpc::internal::ClientWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_GetMaxHitPoint_, context, response); +} + +::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMaxHitPoint_, context, response, true, tag); +} + +::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMaxHitPoint_, context, response, false, nullptr); +} + +::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::GetMinMaxHitPointsRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_GetMinMaxHitPoints_, context); +} + +::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMinMaxHitPoints_, context, true, tag); +} + +::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMinMaxHitPoints_, context, false, nullptr); +} + +MonsterStorage::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::Store), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[1], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::Retrieve), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[2], + ::grpc::internal::RpcMethod::CLIENT_STREAMING, + new ::grpc::internal::ClientStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::GetMaxHitPoint), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[3], + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::GetMinMaxHitPoints), this))); +} + +MonsterStorage::Service::~Service() { +} + +::grpc::Status MonsterStorage::Service::Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* /*response*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +} // namespace MyGame +} // namespace Example + diff --git a/tests/monster_test_suffix/ext_only/monster_test.grpc.fb.h b/tests/monster_test_suffix/ext_only/monster_test.grpc.fb.h new file mode 100644 index 000000000..957c344cd --- /dev/null +++ b/tests/monster_test_suffix/ext_only/monster_test.grpc.fb.h @@ -0,0 +1,350 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: monster_test +#ifndef GRPC_monster_5ftest__INCLUDED +#define GRPC_monster_5ftest__INCLUDED + +#include "monster_test_generated.hpp" +#include "flatbuffers/grpc.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace grpc { +class CompletionQueue; +class Channel; +class ServerCompletionQueue; +class ServerContext; +} // namespace grpc + +namespace MyGame { +namespace Example { + +class MonsterStorage final { + public: + static constexpr char const* service_full_name() { + return "MyGame.Example.MonsterStorage"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + virtual ::grpc::Status Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>> GetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return std::unique_ptr< ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>>(GetMaxHitPointRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>> AsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>>(AsyncGetMaxHitPointRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>> PrepareAsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>>(PrepareAsyncGetMaxHitPointRaw(context, response, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> GetMinMaxHitPoints(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(GetMinMaxHitPointsRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> AsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(AsyncGetMinMaxHitPointsRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> PrepareAsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(PrepareAsyncGetMinMaxHitPointsRaw(context, cq)); + } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>* GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) = 0; + virtual ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>* AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>* PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* GetMinMaxHitPointsRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); + ::grpc::Status Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientWriter< flatbuffers::grpc::Message>> GetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return std::unique_ptr< ::grpc::ClientWriter< flatbuffers::grpc::Message>>(GetMaxHitPointRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>> AsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>>(AsyncGetMaxHitPointRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>> PrepareAsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>>(PrepareAsyncGetMaxHitPointRaw(context, response, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> GetMinMaxHitPoints(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(GetMinMaxHitPointsRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> AsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(AsyncGetMinMaxHitPointsRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> PrepareAsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(PrepareAsyncGetMinMaxHitPointsRaw(context, cq)); + } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) override; + ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientWriter< flatbuffers::grpc::Message>* GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) override; + ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* GetMinMaxHitPointsRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_Store_; + const ::grpc::internal::RpcMethod rpcmethod_Retrieve_; + const ::grpc::internal::RpcMethod rpcmethod_GetMaxHitPoint_; + const ::grpc::internal::RpcMethod rpcmethod_GetMinMaxHitPoints_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + virtual ::grpc::Status Store(::grpc::ServerContext* context, const flatbuffers::grpc::Message* request, flatbuffers::grpc::Message* response); + virtual ::grpc::Status Retrieve(::grpc::ServerContext* context, const flatbuffers::grpc::Message* request, ::grpc::ServerWriter< flatbuffers::grpc::Message>* writer); + virtual ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* context, ::grpc::ServerReader< flatbuffers::grpc::Message>* reader, flatbuffers::grpc::Message* response); + virtual ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* stream); + }; + template + class WithAsyncMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_Store() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStore(::grpc::ServerContext* context, flatbuffers::grpc::Message* request, ::grpc::ServerAsyncResponseWriter< flatbuffers::grpc::Message>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_Retrieve() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRetrieve(::grpc::ServerContext* context, flatbuffers::grpc::Message* request, ::grpc::ServerAsyncWriter< flatbuffers::grpc::Message>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetMaxHitPoint : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_GetMaxHitPoint() { + ::grpc::Service::MarkMethodAsync(2); + } + ~WithAsyncMethod_GetMaxHitPoint() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* response) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetMaxHitPoint(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(2, context, reader, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetMinMaxHitPoints : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_GetMinMaxHitPoints() { + ::grpc::Service::MarkMethodAsync(3); + } + ~WithAsyncMethod_GetMinMaxHitPoints() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetMinMaxHitPoints(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_Store< WithAsyncMethod_Retrieve< WithAsyncMethod_GetMaxHitPoint< WithAsyncMethod_GetMinMaxHitPoints< Service > > > > AsyncService; + template + class WithGenericMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_Store() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_Retrieve() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetMaxHitPoint : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_GetMaxHitPoint() { + ::grpc::Service::MarkMethodGeneric(2); + } + ~WithGenericMethod_GetMaxHitPoint() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetMinMaxHitPoints : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_GetMinMaxHitPoints() { + ::grpc::Service::MarkMethodGeneric(3); + } + ~WithGenericMethod_GetMinMaxHitPoints() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithStreamedUnaryMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithStreamedUnaryMethod_Store() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithStreamedUnaryMethod_Store::StreamedStore, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStore(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< flatbuffers::grpc::Message,flatbuffers::grpc::Message>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_Store< Service > StreamedUnaryService; + template + class WithSplitStreamingMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) { } + public: + WithSplitStreamingMethod_Retrieve() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::SplitServerStreamingHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithSplitStreamingMethod_Retrieve::StreamedRetrieve, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithSplitStreamingMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedRetrieve(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< flatbuffers::grpc::Message,flatbuffers::grpc::Message>* server_split_streamer) = 0; + }; + typedef WithSplitStreamingMethod_Retrieve< Service > SplitStreamedService; + typedef WithStreamedUnaryMethod_Store< WithSplitStreamingMethod_Retrieve< Service > > StreamedService; +}; + +} // namespace Example +} // namespace MyGame + + +#endif // GRPC_monster_5ftest__INCLUDED diff --git a/tests/monster_test_suffix/ext_only/monster_test_generated.hpp b/tests/monster_test_suffix/ext_only/monster_test_generated.hpp new file mode 100644 index 000000000..5e2308c7b --- /dev/null +++ b/tests/monster_test_suffix/ext_only/monster_test_generated.hpp @@ -0,0 +1,4041 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ +#define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ + +#include "flatbuffers/flatbuffers.h" +#include "flatbuffers/flexbuffers.h" +#include "flatbuffers/flex_flat_util.h" + +// Ensure the included flatbuffers.h is the same version as when this file was +// generated, otherwise it may not be compatible. +static_assert(FLATBUFFERS_VERSION_MAJOR == 2 && + FLATBUFFERS_VERSION_MINOR == 0 && + FLATBUFFERS_VERSION_REVISION == 6, + "Non-compatible flatbuffers version included"); + +namespace MyGame { + +struct InParentNamespace; +struct InParentNamespaceBuilder; +struct InParentNamespaceT; + +namespace Example2 { + +struct Monster; +struct MonsterBuilder; +struct MonsterT; + +} // namespace Example2 + +namespace Example { + +struct Test; + +struct TestSimpleTableWithEnum; +struct TestSimpleTableWithEnumBuilder; +struct TestSimpleTableWithEnumT; + +struct Vec3; + +struct Ability; + +struct StructOfStructs; + +struct StructOfStructsOfStructs; + +struct Stat; +struct StatBuilder; +struct StatT; + +struct Referrable; +struct ReferrableBuilder; +struct ReferrableT; + +struct Monster; +struct MonsterBuilder; +struct MonsterT; + +struct TypeAliases; +struct TypeAliasesBuilder; +struct TypeAliasesT; + +} // namespace Example + +bool operator==(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs); +bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs); +namespace Example2 { + +bool operator==(const MonsterT &lhs, const MonsterT &rhs); +bool operator!=(const MonsterT &lhs, const MonsterT &rhs); +} // namespace Example2 + +namespace Example { + +bool operator==(const Test &lhs, const Test &rhs); +bool operator!=(const Test &lhs, const Test &rhs); +bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs); +bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs); +bool operator==(const Vec3 &lhs, const Vec3 &rhs); +bool operator!=(const Vec3 &lhs, const Vec3 &rhs); +bool operator==(const Ability &lhs, const Ability &rhs); +bool operator!=(const Ability &lhs, const Ability &rhs); +bool operator==(const StructOfStructs &lhs, const StructOfStructs &rhs); +bool operator!=(const StructOfStructs &lhs, const StructOfStructs &rhs); +bool operator==(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs); +bool operator!=(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs); +bool operator==(const StatT &lhs, const StatT &rhs); +bool operator!=(const StatT &lhs, const StatT &rhs); +bool operator==(const ReferrableT &lhs, const ReferrableT &rhs); +bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs); +bool operator==(const MonsterT &lhs, const MonsterT &rhs); +bool operator!=(const MonsterT &lhs, const MonsterT &rhs); +bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs); +bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs); + +} // namespace Example + +inline const flatbuffers::TypeTable *InParentNamespaceTypeTable(); + +namespace Example2 { + +inline const flatbuffers::TypeTable *MonsterTypeTable(); + +} // namespace Example2 + +namespace Example { + +inline const flatbuffers::TypeTable *TestTypeTable(); + +inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable(); + +inline const flatbuffers::TypeTable *Vec3TypeTable(); + +inline const flatbuffers::TypeTable *AbilityTypeTable(); + +inline const flatbuffers::TypeTable *StructOfStructsTypeTable(); + +inline const flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable(); + +inline const flatbuffers::TypeTable *StatTypeTable(); + +inline const flatbuffers::TypeTable *ReferrableTypeTable(); + +inline const flatbuffers::TypeTable *MonsterTypeTable(); + +inline const flatbuffers::TypeTable *TypeAliasesTypeTable(); + +/// Composite components of Monster color. +enum Color : uint8_t { + Color_Red = 1, + /// \brief color Green + /// Green is bit_flag with value (1u << 1) + Color_Green = 2, + /// \brief color Blue (1u << 3) + Color_Blue = 8, + Color_NONE = 0, + Color_ANY = 11 +}; + +inline const Color (&EnumValuesColor())[3] { + static const Color values[] = { + Color_Red, + Color_Green, + Color_Blue + }; + return values; +} + +inline const char * const *EnumNamesColor() { + static const char * const names[9] = { + "Red", + "Green", + "", + "", + "", + "", + "", + "Blue", + nullptr + }; + return names; +} + +inline const char *EnumNameColor(Color e) { + if (flatbuffers::IsOutRange(e, Color_Red, Color_Blue)) return ""; + const size_t index = static_cast(e) - static_cast(Color_Red); + return EnumNamesColor()[index]; +} + +enum Race : int8_t { + Race_None = -1, + Race_Human = 0, + Race_Dwarf = 1, + Race_Elf = 2, + Race_MIN = Race_None, + Race_MAX = Race_Elf +}; + +inline const Race (&EnumValuesRace())[4] { + static const Race values[] = { + Race_None, + Race_Human, + Race_Dwarf, + Race_Elf + }; + return values; +} + +inline const char * const *EnumNamesRace() { + static const char * const names[5] = { + "None", + "Human", + "Dwarf", + "Elf", + nullptr + }; + return names; +} + +inline const char *EnumNameRace(Race e) { + if (flatbuffers::IsOutRange(e, Race_None, Race_Elf)) return ""; + const size_t index = static_cast(e) - static_cast(Race_None); + return EnumNamesRace()[index]; +} + +enum LongEnum : uint64_t { + LongEnum_LongOne = 2ULL, + LongEnum_LongTwo = 4ULL, + LongEnum_LongBig = 1099511627776ULL, + LongEnum_NONE = 0, + LongEnum_ANY = 1099511627782ULL +}; + +inline const LongEnum (&EnumValuesLongEnum())[3] { + static const LongEnum values[] = { + LongEnum_LongOne, + LongEnum_LongTwo, + LongEnum_LongBig + }; + return values; +} + +inline const char *EnumNameLongEnum(LongEnum e) { + switch (e) { + case LongEnum_LongOne: return "LongOne"; + case LongEnum_LongTwo: return "LongTwo"; + case LongEnum_LongBig: return "LongBig"; + default: return ""; + } +} + +enum Any : uint8_t { + Any_NONE = 0, + Any_Monster = 1, + Any_TestSimpleTableWithEnum = 2, + Any_MyGame_Example2_Monster = 3, + Any_MIN = Any_NONE, + Any_MAX = Any_MyGame_Example2_Monster +}; + +inline const Any (&EnumValuesAny())[4] { + static const Any values[] = { + Any_NONE, + Any_Monster, + Any_TestSimpleTableWithEnum, + Any_MyGame_Example2_Monster + }; + return values; +} + +inline const char * const *EnumNamesAny() { + static const char * const names[5] = { + "NONE", + "Monster", + "TestSimpleTableWithEnum", + "MyGame_Example2_Monster", + nullptr + }; + return names; +} + +inline const char *EnumNameAny(Any e) { + if (flatbuffers::IsOutRange(e, Any_NONE, Any_MyGame_Example2_Monster)) return ""; + const size_t index = static_cast(e); + return EnumNamesAny()[index]; +} + +template struct AnyTraits { + static const Any enum_value = Any_NONE; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_Monster; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_TestSimpleTableWithEnum; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_MyGame_Example2_Monster; +}; + +template struct AnyUnionTraits { + static const Any enum_value = Any_NONE; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_Monster; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_TestSimpleTableWithEnum; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_MyGame_Example2_Monster; +}; + +struct AnyUnion { + Any type; + void *value; + + AnyUnion() : type(Any_NONE), value(nullptr) {} + AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT : + type(Any_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyUnion(const AnyUnion &); + AnyUnion &operator=(const AnyUnion &u) + { AnyUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = AnyUnionTraits::enum_value; + if (type != Any_NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsMonster() { + return type == Any_Monster ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsMonster() const { + return type == Any_Monster ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() { + return type == Any_TestSimpleTableWithEnum ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() const { + return type == Any_TestSimpleTableWithEnum ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() { + return type == Any_MyGame_Example2_Monster ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() const { + return type == Any_MyGame_Example2_Monster ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyUnion &lhs, const AnyUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case Any_NONE: { + return true; + } + case Any_Monster: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case Any_TestSimpleTableWithEnum: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case Any_MyGame_Example2_Monster: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type); +bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum AnyUniqueAliases : uint8_t { + AnyUniqueAliases_NONE = 0, + AnyUniqueAliases_M = 1, + AnyUniqueAliases_TS = 2, + AnyUniqueAliases_M2 = 3, + AnyUniqueAliases_MIN = AnyUniqueAliases_NONE, + AnyUniqueAliases_MAX = AnyUniqueAliases_M2 +}; + +inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] { + static const AnyUniqueAliases values[] = { + AnyUniqueAliases_NONE, + AnyUniqueAliases_M, + AnyUniqueAliases_TS, + AnyUniqueAliases_M2 + }; + return values; +} + +inline const char * const *EnumNamesAnyUniqueAliases() { + static const char * const names[5] = { + "NONE", + "M", + "TS", + "M2", + nullptr + }; + return names; +} + +inline const char *EnumNameAnyUniqueAliases(AnyUniqueAliases e) { + if (flatbuffers::IsOutRange(e, AnyUniqueAliases_NONE, AnyUniqueAliases_M2)) return ""; + const size_t index = static_cast(e); + return EnumNamesAnyUniqueAliases()[index]; +} + +template struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2; +}; + +template struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2; +}; + +struct AnyUniqueAliasesUnion { + AnyUniqueAliases type; + void *value; + + AnyUniqueAliasesUnion() : type(AnyUniqueAliases_NONE), value(nullptr) {} + AnyUniqueAliasesUnion(AnyUniqueAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(AnyUniqueAliases_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &); + AnyUniqueAliasesUnion &operator=(const AnyUniqueAliasesUnion &u) + { AnyUniqueAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyUniqueAliasesUnion &operator=(AnyUniqueAliasesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyUniqueAliasesUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = AnyUniqueAliasesUnionTraits::enum_value; + if (type != AnyUniqueAliases_NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsM() { + return type == AnyUniqueAliases_M ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM() const { + return type == AnyUniqueAliases_M ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::TestSimpleTableWithEnumT *AsTS() { + return type == AnyUniqueAliases_TS ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnumT *AsTS() const { + return type == AnyUniqueAliases_TS ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example2::MonsterT *AsM2() { + return type == AnyUniqueAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example2::MonsterT *AsM2() const { + return type == AnyUniqueAliases_M2 ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case AnyUniqueAliases_NONE: { + return true; + } + case AnyUniqueAliases_M: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyUniqueAliases_TS: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyUniqueAliases_M2: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type); +bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum AnyAmbiguousAliases : uint8_t { + AnyAmbiguousAliases_NONE = 0, + AnyAmbiguousAliases_M1 = 1, + AnyAmbiguousAliases_M2 = 2, + AnyAmbiguousAliases_M3 = 3, + AnyAmbiguousAliases_MIN = AnyAmbiguousAliases_NONE, + AnyAmbiguousAliases_MAX = AnyAmbiguousAliases_M3 +}; + +inline const AnyAmbiguousAliases (&EnumValuesAnyAmbiguousAliases())[4] { + static const AnyAmbiguousAliases values[] = { + AnyAmbiguousAliases_NONE, + AnyAmbiguousAliases_M1, + AnyAmbiguousAliases_M2, + AnyAmbiguousAliases_M3 + }; + return values; +} + +inline const char * const *EnumNamesAnyAmbiguousAliases() { + static const char * const names[5] = { + "NONE", + "M1", + "M2", + "M3", + nullptr + }; + return names; +} + +inline const char *EnumNameAnyAmbiguousAliases(AnyAmbiguousAliases e) { + if (flatbuffers::IsOutRange(e, AnyAmbiguousAliases_NONE, AnyAmbiguousAliases_M3)) return ""; + const size_t index = static_cast(e); + return EnumNamesAnyAmbiguousAliases()[index]; +} + +struct AnyAmbiguousAliasesUnion { + AnyAmbiguousAliases type; + void *value; + + AnyAmbiguousAliasesUnion() : type(AnyAmbiguousAliases_NONE), value(nullptr) {} + AnyAmbiguousAliasesUnion(AnyAmbiguousAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(AnyAmbiguousAliases_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &); + AnyAmbiguousAliasesUnion &operator=(const AnyAmbiguousAliasesUnion &u) + { AnyAmbiguousAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyAmbiguousAliasesUnion &operator=(AnyAmbiguousAliasesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyAmbiguousAliasesUnion() { Reset(); } + + void Reset(); + + static void *UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsM1() { + return type == AnyAmbiguousAliases_M1 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM1() const { + return type == AnyAmbiguousAliases_M1 ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::MonsterT *AsM2() { + return type == AnyAmbiguousAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM2() const { + return type == AnyAmbiguousAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::MonsterT *AsM3() { + return type == AnyAmbiguousAliases_M3 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM3() const { + return type == AnyAmbiguousAliases_M3 ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case AnyAmbiguousAliases_NONE: { + return true; + } + case AnyAmbiguousAliases_M1: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyAmbiguousAliases_M2: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyAmbiguousAliases_M3: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type); +bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS { + private: + int16_t a_; + int8_t b_; + int8_t padding0__; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TestTypeTable(); + } + Test() + : a_(0), + b_(0), + padding0__(0) { + (void)padding0__; + } + Test(int16_t _a, int8_t _b) + : a_(flatbuffers::EndianScalar(_a)), + b_(flatbuffers::EndianScalar(_b)), + padding0__(0) { + (void)padding0__; + } + int16_t a() const { + return flatbuffers::EndianScalar(a_); + } + void mutate_a(int16_t _a) { + flatbuffers::WriteScalar(&a_, _a); + } + int8_t b() const { + return flatbuffers::EndianScalar(b_); + } + void mutate_b(int8_t _b) { + flatbuffers::WriteScalar(&b_, _b); + } +}; +FLATBUFFERS_STRUCT_END(Test, 4); + +inline bool operator==(const Test &lhs, const Test &rhs) { + return + (lhs.a() == rhs.a()) && + (lhs.b() == rhs.b()); +} + +inline bool operator!=(const Test &lhs, const Test &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Vec3 FLATBUFFERS_FINAL_CLASS { + private: + float x_; + float y_; + float z_; + int32_t padding0__; + double test1_; + uint8_t test2_; + int8_t padding1__; + MyGame::Example::Test test3_; + int16_t padding2__; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return Vec3TypeTable(); + } + Vec3() + : x_(0), + y_(0), + z_(0), + padding0__(0), + test1_(0), + test2_(0), + padding1__(0), + test3_(), + padding2__(0) { + (void)padding0__; + (void)padding1__; + (void)padding2__; + } + Vec3(float _x, float _y, float _z, double _test1, MyGame::Example::Color _test2, const MyGame::Example::Test &_test3) + : x_(flatbuffers::EndianScalar(_x)), + y_(flatbuffers::EndianScalar(_y)), + z_(flatbuffers::EndianScalar(_z)), + padding0__(0), + test1_(flatbuffers::EndianScalar(_test1)), + test2_(flatbuffers::EndianScalar(static_cast(_test2))), + padding1__(0), + test3_(_test3), + padding2__(0) { + (void)padding0__; + (void)padding1__; + (void)padding2__; + } + float x() const { + return flatbuffers::EndianScalar(x_); + } + void mutate_x(float _x) { + flatbuffers::WriteScalar(&x_, _x); + } + float y() const { + return flatbuffers::EndianScalar(y_); + } + void mutate_y(float _y) { + flatbuffers::WriteScalar(&y_, _y); + } + float z() const { + return flatbuffers::EndianScalar(z_); + } + void mutate_z(float _z) { + flatbuffers::WriteScalar(&z_, _z); + } + double test1() const { + return flatbuffers::EndianScalar(test1_); + } + void mutate_test1(double _test1) { + flatbuffers::WriteScalar(&test1_, _test1); + } + MyGame::Example::Color test2() const { + return static_cast(flatbuffers::EndianScalar(test2_)); + } + void mutate_test2(MyGame::Example::Color _test2) { + flatbuffers::WriteScalar(&test2_, static_cast(_test2)); + } + const MyGame::Example::Test &test3() const { + return test3_; + } + MyGame::Example::Test &mutable_test3() { + return test3_; + } +}; +FLATBUFFERS_STRUCT_END(Vec3, 32); + +inline bool operator==(const Vec3 &lhs, const Vec3 &rhs) { + return + (lhs.x() == rhs.x()) && + (lhs.y() == rhs.y()) && + (lhs.z() == rhs.z()) && + (lhs.test1() == rhs.test1()) && + (lhs.test2() == rhs.test2()) && + (lhs.test3() == rhs.test3()); +} + +inline bool operator!=(const Vec3 &lhs, const Vec3 &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ability FLATBUFFERS_FINAL_CLASS { + private: + uint32_t id_; + uint32_t distance_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return AbilityTypeTable(); + } + Ability() + : id_(0), + distance_(0) { + } + Ability(uint32_t _id, uint32_t _distance) + : id_(flatbuffers::EndianScalar(_id)), + distance_(flatbuffers::EndianScalar(_distance)) { + } + uint32_t id() const { + return flatbuffers::EndianScalar(id_); + } + void mutate_id(uint32_t _id) { + flatbuffers::WriteScalar(&id_, _id); + } + bool KeyCompareLessThan(const Ability *o) const { + return id() < o->id(); + } + int KeyCompareWithValue(uint32_t _id) const { + return static_cast(id() > _id) - static_cast(id() < _id); + } + uint32_t distance() const { + return flatbuffers::EndianScalar(distance_); + } + void mutate_distance(uint32_t _distance) { + flatbuffers::WriteScalar(&distance_, _distance); + } +}; +FLATBUFFERS_STRUCT_END(Ability, 8); + +inline bool operator==(const Ability &lhs, const Ability &rhs) { + return + (lhs.id() == rhs.id()) && + (lhs.distance() == rhs.distance()); +} + +inline bool operator!=(const Ability &lhs, const Ability &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructs FLATBUFFERS_FINAL_CLASS { + private: + MyGame::Example::Ability a_; + MyGame::Example::Test b_; + MyGame::Example::Ability c_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StructOfStructsTypeTable(); + } + StructOfStructs() + : a_(), + b_(), + c_() { + } + StructOfStructs(const MyGame::Example::Ability &_a, const MyGame::Example::Test &_b, const MyGame::Example::Ability &_c) + : a_(_a), + b_(_b), + c_(_c) { + } + const MyGame::Example::Ability &a() const { + return a_; + } + MyGame::Example::Ability &mutable_a() { + return a_; + } + const MyGame::Example::Test &b() const { + return b_; + } + MyGame::Example::Test &mutable_b() { + return b_; + } + const MyGame::Example::Ability &c() const { + return c_; + } + MyGame::Example::Ability &mutable_c() { + return c_; + } +}; +FLATBUFFERS_STRUCT_END(StructOfStructs, 20); + +inline bool operator==(const StructOfStructs &lhs, const StructOfStructs &rhs) { + return + (lhs.a() == rhs.a()) && + (lhs.b() == rhs.b()) && + (lhs.c() == rhs.c()); +} + +inline bool operator!=(const StructOfStructs &lhs, const StructOfStructs &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructsOfStructs FLATBUFFERS_FINAL_CLASS { + private: + MyGame::Example::StructOfStructs a_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StructOfStructsOfStructsTypeTable(); + } + StructOfStructsOfStructs() + : a_() { + } + StructOfStructsOfStructs(const MyGame::Example::StructOfStructs &_a) + : a_(_a) { + } + const MyGame::Example::StructOfStructs &a() const { + return a_; + } + MyGame::Example::StructOfStructs &mutable_a() { + return a_; + } +}; +FLATBUFFERS_STRUCT_END(StructOfStructsOfStructs, 20); + +inline bool operator==(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs) { + return + (lhs.a() == rhs.a()); +} + +inline bool operator!=(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs) { + return !(lhs == rhs); +} + + +} // namespace Example + +struct InParentNamespaceT : public flatbuffers::NativeTable { + typedef InParentNamespace TableType; +}; + +struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InParentNamespaceT NativeTableType; + typedef InParentNamespaceBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return InParentNamespaceTypeTable(); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } + InParentNamespaceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct InParentNamespaceBuilder { + typedef InParentNamespace Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit InParentNamespaceBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInParentNamespace( + flatbuffers::FlatBufferBuilder &_fbb) { + InParentNamespaceBuilder builder_(_fbb); + return builder_.Finish(); +} + +flatbuffers::Offset CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +namespace Example2 { + +struct MonsterT : public flatbuffers::NativeTable { + typedef Monster TableType; +}; + +struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MonsterT NativeTableType; + typedef MonsterBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return MonsterTypeTable(); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } + MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct MonsterBuilder { + typedef Monster Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb) { + MonsterBuilder builder_(_fbb); + return builder_.Finish(); +} + +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +} // namespace Example2 + +namespace Example { + +struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable { + typedef TestSimpleTableWithEnum TableType; + MyGame::Example::Color color = MyGame::Example::Color_Green; +}; + +struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TestSimpleTableWithEnumT NativeTableType; + typedef TestSimpleTableWithEnumBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TestSimpleTableWithEnumTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_COLOR = 4 + }; + MyGame::Example::Color color() const { + return static_cast(GetField(VT_COLOR, 2)); + } + bool mutate_color(MyGame::Example::Color _color = static_cast(2)) { + return SetField(VT_COLOR, static_cast(_color), 2); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_COLOR, 1) && + verifier.EndTable(); + } + TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TestSimpleTableWithEnumBuilder { + typedef TestSimpleTableWithEnum Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_color(MyGame::Example::Color color) { + fbb_.AddElement(TestSimpleTableWithEnum::VT_COLOR, static_cast(color), 2); + } + explicit TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTestSimpleTableWithEnum( + flatbuffers::FlatBufferBuilder &_fbb, + MyGame::Example::Color color = MyGame::Example::Color_Green) { + TestSimpleTableWithEnumBuilder builder_(_fbb); + builder_.add_color(color); + return builder_.Finish(); +} + +flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct StatT : public flatbuffers::NativeTable { + typedef Stat TableType; + std::string id{}; + int64_t val = 0; + uint16_t count = 0; +}; + +struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StatT NativeTableType; + typedef StatBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StatTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4, + VT_VAL = 6, + VT_COUNT = 8 + }; + const flatbuffers::String *id() const { + return GetPointer(VT_ID); + } + flatbuffers::String *mutable_id() { + return GetPointer(VT_ID); + } + int64_t val() const { + return GetField(VT_VAL, 0); + } + bool mutate_val(int64_t _val = 0) { + return SetField(VT_VAL, _val, 0); + } + uint16_t count() const { + return GetField(VT_COUNT, 0); + } + bool mutate_count(uint16_t _count = 0) { + return SetField(VT_COUNT, _count, 0); + } + bool KeyCompareLessThan(const Stat *o) const { + return count() < o->count(); + } + int KeyCompareWithValue(uint16_t _count) const { + return static_cast(count() > _count) - static_cast(count() < _count); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ID) && + verifier.VerifyString(id()) && + VerifyField(verifier, VT_VAL, 8) && + VerifyField(verifier, VT_COUNT, 2) && + verifier.EndTable(); + } + StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct StatBuilder { + typedef Stat Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(flatbuffers::Offset id) { + fbb_.AddOffset(Stat::VT_ID, id); + } + void add_val(int64_t val) { + fbb_.AddElement(Stat::VT_VAL, val, 0); + } + void add_count(uint16_t count) { + fbb_.AddElement(Stat::VT_COUNT, count, 0); + } + explicit StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStat( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset id = 0, + int64_t val = 0, + uint16_t count = 0) { + StatBuilder builder_(_fbb); + builder_.add_val(val); + builder_.add_id(id); + builder_.add_count(count); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStatDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *id = nullptr, + int64_t val = 0, + uint16_t count = 0) { + auto id__ = id ? _fbb.CreateString(id) : 0; + return MyGame::Example::CreateStat( + _fbb, + id__, + val, + count); +} + +flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReferrableT : public flatbuffers::NativeTable { + typedef Referrable TableType; + uint64_t id = 0; +}; + +struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReferrableT NativeTableType; + typedef ReferrableBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return ReferrableTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4 + }; + uint64_t id() const { + return GetField(VT_ID, 0); + } + bool mutate_id(uint64_t _id = 0) { + return SetField(VT_ID, _id, 0); + } + bool KeyCompareLessThan(const Referrable *o) const { + return id() < o->id(); + } + int KeyCompareWithValue(uint64_t _id) const { + return static_cast(id() > _id) - static_cast(id() < _id); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ID, 8) && + verifier.EndTable(); + } + ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReferrableBuilder { + typedef Referrable Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(uint64_t id) { + fbb_.AddElement(Referrable::VT_ID, id, 0); + } + explicit ReferrableBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateReferrable( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t id = 0) { + ReferrableBuilder builder_(_fbb); + builder_.add_id(id); + return builder_.Finish(); +} + +flatbuffers::Offset CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct MonsterT : public flatbuffers::NativeTable { + typedef Monster TableType; + flatbuffers::unique_ptr pos{}; + int16_t mana = 150; + int16_t hp = 100; + std::string name{}; + std::vector inventory{}; + MyGame::Example::Color color = MyGame::Example::Color_Blue; + MyGame::Example::AnyUnion test{}; + std::vector test4{}; + std::vector testarrayofstring{}; + std::vector> testarrayoftables{}; + flatbuffers::unique_ptr enemy{}; + std::vector testnestedflatbuffer{}; + flatbuffers::unique_ptr testempty{}; + bool testbool = false; + int32_t testhashs32_fnv1 = 0; + uint32_t testhashu32_fnv1 = 0; + int64_t testhashs64_fnv1 = 0; + uint64_t testhashu64_fnv1 = 0; + int32_t testhashs32_fnv1a = 0; + Stat *testhashu32_fnv1a = nullptr; + int64_t testhashs64_fnv1a = 0; + uint64_t testhashu64_fnv1a = 0; + std::vector testarrayofbools{}; + float testf = 3.14159f; + float testf2 = 3.0f; + float testf3 = 0.0f; + std::vector testarrayofstring2{}; + std::vector testarrayofsortedstruct{}; + std::vector flex{}; + std::vector test5{}; + std::vector vector_of_longs{}; + std::vector vector_of_doubles{}; + flatbuffers::unique_ptr parent_namespace_test{}; + std::vector> vector_of_referrables{}; + ReferrableT *single_weak_reference = nullptr; + std::vector vector_of_weak_references{}; + std::vector> vector_of_strong_referrables{}; + ReferrableT *co_owning_reference = nullptr; + std::vector> vector_of_co_owning_references{}; + ReferrableT *non_owning_reference = nullptr; + std::vector vector_of_non_owning_references{}; + MyGame::Example::AnyUniqueAliasesUnion any_unique{}; + MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous{}; + std::vector vector_of_enums{}; + MyGame::Example::Race signed_enum = MyGame::Example::Race_None; + std::vector testrequirednestedflatbuffer{}; + std::vector> scalar_key_sorted_tables{}; + MyGame::Example::Test native_inline{}; + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0); + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne; + MonsterT() = default; + MonsterT(const MonsterT &o); + MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default; + MonsterT &operator=(MonsterT o) FLATBUFFERS_NOEXCEPT; +}; + +/// an example documentation comment: "monster object" +struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MonsterT NativeTableType; + typedef MonsterBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return MonsterTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POS = 4, + VT_MANA = 6, + VT_HP = 8, + VT_NAME = 10, + VT_INVENTORY = 14, + VT_COLOR = 16, + VT_TEST_TYPE = 18, + VT_TEST = 20, + VT_TEST4 = 22, + VT_TESTARRAYOFSTRING = 24, + VT_TESTARRAYOFTABLES = 26, + VT_ENEMY = 28, + VT_TESTNESTEDFLATBUFFER = 30, + VT_TESTEMPTY = 32, + VT_TESTBOOL = 34, + VT_TESTHASHS32_FNV1 = 36, + VT_TESTHASHU32_FNV1 = 38, + VT_TESTHASHS64_FNV1 = 40, + VT_TESTHASHU64_FNV1 = 42, + VT_TESTHASHS32_FNV1A = 44, + VT_TESTHASHU32_FNV1A = 46, + VT_TESTHASHS64_FNV1A = 48, + VT_TESTHASHU64_FNV1A = 50, + VT_TESTARRAYOFBOOLS = 52, + VT_TESTF = 54, + VT_TESTF2 = 56, + VT_TESTF3 = 58, + VT_TESTARRAYOFSTRING2 = 60, + VT_TESTARRAYOFSORTEDSTRUCT = 62, + VT_FLEX = 64, + VT_TEST5 = 66, + VT_VECTOR_OF_LONGS = 68, + VT_VECTOR_OF_DOUBLES = 70, + VT_PARENT_NAMESPACE_TEST = 72, + VT_VECTOR_OF_REFERRABLES = 74, + VT_SINGLE_WEAK_REFERENCE = 76, + VT_VECTOR_OF_WEAK_REFERENCES = 78, + VT_VECTOR_OF_STRONG_REFERRABLES = 80, + VT_CO_OWNING_REFERENCE = 82, + VT_VECTOR_OF_CO_OWNING_REFERENCES = 84, + VT_NON_OWNING_REFERENCE = 86, + VT_VECTOR_OF_NON_OWNING_REFERENCES = 88, + VT_ANY_UNIQUE_TYPE = 90, + VT_ANY_UNIQUE = 92, + VT_ANY_AMBIGUOUS_TYPE = 94, + VT_ANY_AMBIGUOUS = 96, + VT_VECTOR_OF_ENUMS = 98, + VT_SIGNED_ENUM = 100, + VT_TESTREQUIREDNESTEDFLATBUFFER = 102, + VT_SCALAR_KEY_SORTED_TABLES = 104, + VT_NATIVE_INLINE = 106, + VT_LONG_ENUM_NON_ENUM_DEFAULT = 108, + VT_LONG_ENUM_NORMAL_DEFAULT = 110 + }; + const MyGame::Example::Vec3 *pos() const { + return GetStruct(VT_POS); + } + MyGame::Example::Vec3 *mutable_pos() { + return GetStruct(VT_POS); + } + int16_t mana() const { + return GetField(VT_MANA, 150); + } + bool mutate_mana(int16_t _mana = 150) { + return SetField(VT_MANA, _mana, 150); + } + int16_t hp() const { + return GetField(VT_HP, 100); + } + bool mutate_hp(int16_t _hp = 100) { + return SetField(VT_HP, _hp, 100); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + flatbuffers::String *mutable_name() { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Monster *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *_name) const { + return strcmp(name()->c_str(), _name); + } + const flatbuffers::Vector *inventory() const { + return GetPointer *>(VT_INVENTORY); + } + flatbuffers::Vector *mutable_inventory() { + return GetPointer *>(VT_INVENTORY); + } + MyGame::Example::Color color() const { + return static_cast(GetField(VT_COLOR, 8)); + } + bool mutate_color(MyGame::Example::Color _color = static_cast(8)) { + return SetField(VT_COLOR, static_cast(_color), 8); + } + MyGame::Example::Any test_type() const { + return static_cast(GetField(VT_TEST_TYPE, 0)); + } + const void *test() const { + return GetPointer(VT_TEST); + } + template const T *test_as() const; + const MyGame::Example::Monster *test_as_Monster() const { + return test_type() == MyGame::Example::Any_Monster ? static_cast(test()) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const { + return test_type() == MyGame::Example::Any_TestSimpleTableWithEnum ? static_cast(test()) : nullptr; + } + const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const { + return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast(test()) : nullptr; + } + void *mutable_test() { + return GetPointer(VT_TEST); + } + const flatbuffers::Vector *test4() const { + return GetPointer *>(VT_TEST4); + } + flatbuffers::Vector *mutable_test4() { + return GetPointer *>(VT_TEST4); + } + const flatbuffers::Vector> *testarrayofstring() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } + flatbuffers::Vector> *mutable_testarrayofstring() { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } + /// an example documentation comment: this will end up in the generated code + /// multiline too + const flatbuffers::Vector> *testarrayoftables() const { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + flatbuffers::Vector> *mutable_testarrayoftables() { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + const MyGame::Example::Monster *enemy() const { + return GetPointer(VT_ENEMY); + } + MyGame::Example::Monster *mutable_enemy() { + return GetPointer(VT_ENEMY); + } + const flatbuffers::Vector *testnestedflatbuffer() const { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + flatbuffers::Vector *mutable_testnestedflatbuffer() { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const { + return flatbuffers::GetRoot(testnestedflatbuffer()->Data()); + } + const MyGame::Example::Stat *testempty() const { + return GetPointer(VT_TESTEMPTY); + } + MyGame::Example::Stat *mutable_testempty() { + return GetPointer(VT_TESTEMPTY); + } + bool testbool() const { + return GetField(VT_TESTBOOL, 0) != 0; + } + bool mutate_testbool(bool _testbool = 0) { + return SetField(VT_TESTBOOL, static_cast(_testbool), 0); + } + int32_t testhashs32_fnv1() const { + return GetField(VT_TESTHASHS32_FNV1, 0); + } + bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1 = 0) { + return SetField(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0); + } + uint32_t testhashu32_fnv1() const { + return GetField(VT_TESTHASHU32_FNV1, 0); + } + bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1 = 0) { + return SetField(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0); + } + int64_t testhashs64_fnv1() const { + return GetField(VT_TESTHASHS64_FNV1, 0); + } + bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1 = 0) { + return SetField(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0); + } + uint64_t testhashu64_fnv1() const { + return GetField(VT_TESTHASHU64_FNV1, 0); + } + bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1 = 0) { + return SetField(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0); + } + int32_t testhashs32_fnv1a() const { + return GetField(VT_TESTHASHS32_FNV1A, 0); + } + bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a = 0) { + return SetField(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0); + } + uint32_t testhashu32_fnv1a() const { + return GetField(VT_TESTHASHU32_FNV1A, 0); + } + bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a = 0) { + return SetField(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0); + } + int64_t testhashs64_fnv1a() const { + return GetField(VT_TESTHASHS64_FNV1A, 0); + } + bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a = 0) { + return SetField(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0); + } + uint64_t testhashu64_fnv1a() const { + return GetField(VT_TESTHASHU64_FNV1A, 0); + } + bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a = 0) { + return SetField(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0); + } + const flatbuffers::Vector *testarrayofbools() const { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + flatbuffers::Vector *mutable_testarrayofbools() { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + float testf() const { + return GetField(VT_TESTF, 3.14159f); + } + bool mutate_testf(float _testf = 3.14159f) { + return SetField(VT_TESTF, _testf, 3.14159f); + } + float testf2() const { + return GetField(VT_TESTF2, 3.0f); + } + bool mutate_testf2(float _testf2 = 3.0f) { + return SetField(VT_TESTF2, _testf2, 3.0f); + } + float testf3() const { + return GetField(VT_TESTF3, 0.0f); + } + bool mutate_testf3(float _testf3 = 0.0f) { + return SetField(VT_TESTF3, _testf3, 0.0f); + } + const flatbuffers::Vector> *testarrayofstring2() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } + flatbuffers::Vector> *mutable_testarrayofstring2() { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } + const flatbuffers::Vector *testarrayofsortedstruct() const { + return GetPointer *>(VT_TESTARRAYOFSORTEDSTRUCT); + } + flatbuffers::Vector *mutable_testarrayofsortedstruct() { + return GetPointer *>(VT_TESTARRAYOFSORTEDSTRUCT); + } + const flatbuffers::Vector *flex() const { + return GetPointer *>(VT_FLEX); + } + flatbuffers::Vector *mutable_flex() { + return GetPointer *>(VT_FLEX); + } + flexbuffers::Reference flex_flexbuffer_root() const { + return flexbuffers::GetRoot(flex()->Data(), flex()->size()); + } + const flatbuffers::Vector *test5() const { + return GetPointer *>(VT_TEST5); + } + flatbuffers::Vector *mutable_test5() { + return GetPointer *>(VT_TEST5); + } + const flatbuffers::Vector *vector_of_longs() const { + return GetPointer *>(VT_VECTOR_OF_LONGS); + } + flatbuffers::Vector *mutable_vector_of_longs() { + return GetPointer *>(VT_VECTOR_OF_LONGS); + } + const flatbuffers::Vector *vector_of_doubles() const { + return GetPointer *>(VT_VECTOR_OF_DOUBLES); + } + flatbuffers::Vector *mutable_vector_of_doubles() { + return GetPointer *>(VT_VECTOR_OF_DOUBLES); + } + const MyGame::InParentNamespace *parent_namespace_test() const { + return GetPointer(VT_PARENT_NAMESPACE_TEST); + } + MyGame::InParentNamespace *mutable_parent_namespace_test() { + return GetPointer(VT_PARENT_NAMESPACE_TEST); + } + const flatbuffers::Vector> *vector_of_referrables() const { + return GetPointer> *>(VT_VECTOR_OF_REFERRABLES); + } + flatbuffers::Vector> *mutable_vector_of_referrables() { + return GetPointer> *>(VT_VECTOR_OF_REFERRABLES); + } + uint64_t single_weak_reference() const { + return GetField(VT_SINGLE_WEAK_REFERENCE, 0); + } + bool mutate_single_weak_reference(uint64_t _single_weak_reference = 0) { + return SetField(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0); + } + const flatbuffers::Vector *vector_of_weak_references() const { + return GetPointer *>(VT_VECTOR_OF_WEAK_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_weak_references() { + return GetPointer *>(VT_VECTOR_OF_WEAK_REFERENCES); + } + const flatbuffers::Vector> *vector_of_strong_referrables() const { + return GetPointer> *>(VT_VECTOR_OF_STRONG_REFERRABLES); + } + flatbuffers::Vector> *mutable_vector_of_strong_referrables() { + return GetPointer> *>(VT_VECTOR_OF_STRONG_REFERRABLES); + } + uint64_t co_owning_reference() const { + return GetField(VT_CO_OWNING_REFERENCE, 0); + } + bool mutate_co_owning_reference(uint64_t _co_owning_reference = 0) { + return SetField(VT_CO_OWNING_REFERENCE, _co_owning_reference, 0); + } + const flatbuffers::Vector *vector_of_co_owning_references() const { + return GetPointer *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_co_owning_references() { + return GetPointer *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); + } + uint64_t non_owning_reference() const { + return GetField(VT_NON_OWNING_REFERENCE, 0); + } + bool mutate_non_owning_reference(uint64_t _non_owning_reference = 0) { + return SetField(VT_NON_OWNING_REFERENCE, _non_owning_reference, 0); + } + const flatbuffers::Vector *vector_of_non_owning_references() const { + return GetPointer *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_non_owning_references() { + return GetPointer *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); + } + MyGame::Example::AnyUniqueAliases any_unique_type() const { + return static_cast(GetField(VT_ANY_UNIQUE_TYPE, 0)); + } + const void *any_unique() const { + return GetPointer(VT_ANY_UNIQUE); + } + template const T *any_unique_as() const; + const MyGame::Example::Monster *any_unique_as_M() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_M ? static_cast(any_unique()) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnum *any_unique_as_TS() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_TS ? static_cast(any_unique()) : nullptr; + } + const MyGame::Example2::Monster *any_unique_as_M2() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast(any_unique()) : nullptr; + } + void *mutable_any_unique() { + return GetPointer(VT_ANY_UNIQUE); + } + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type() const { + return static_cast(GetField(VT_ANY_AMBIGUOUS_TYPE, 0)); + } + const void *any_ambiguous() const { + return GetPointer(VT_ANY_AMBIGUOUS); + } + const MyGame::Example::Monster *any_ambiguous_as_M1() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M1 ? static_cast(any_ambiguous()) : nullptr; + } + const MyGame::Example::Monster *any_ambiguous_as_M2() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M2 ? static_cast(any_ambiguous()) : nullptr; + } + const MyGame::Example::Monster *any_ambiguous_as_M3() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast(any_ambiguous()) : nullptr; + } + void *mutable_any_ambiguous() { + return GetPointer(VT_ANY_AMBIGUOUS); + } + const flatbuffers::Vector *vector_of_enums() const { + return GetPointer *>(VT_VECTOR_OF_ENUMS); + } + flatbuffers::Vector *mutable_vector_of_enums() { + return GetPointer *>(VT_VECTOR_OF_ENUMS); + } + MyGame::Example::Race signed_enum() const { + return static_cast(GetField(VT_SIGNED_ENUM, -1)); + } + bool mutate_signed_enum(MyGame::Example::Race _signed_enum = static_cast(-1)) { + return SetField(VT_SIGNED_ENUM, static_cast(_signed_enum), -1); + } + const flatbuffers::Vector *testrequirednestedflatbuffer() const { + return GetPointer *>(VT_TESTREQUIREDNESTEDFLATBUFFER); + } + flatbuffers::Vector *mutable_testrequirednestedflatbuffer() { + return GetPointer *>(VT_TESTREQUIREDNESTEDFLATBUFFER); + } + const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const { + return flatbuffers::GetRoot(testrequirednestedflatbuffer()->Data()); + } + const flatbuffers::Vector> *scalar_key_sorted_tables() const { + return GetPointer> *>(VT_SCALAR_KEY_SORTED_TABLES); + } + flatbuffers::Vector> *mutable_scalar_key_sorted_tables() { + return GetPointer> *>(VT_SCALAR_KEY_SORTED_TABLES); + } + const MyGame::Example::Test *native_inline() const { + return GetStruct(VT_NATIVE_INLINE); + } + MyGame::Example::Test *mutable_native_inline() { + return GetStruct(VT_NATIVE_INLINE); + } + MyGame::Example::LongEnum long_enum_non_enum_default() const { + return static_cast(GetField(VT_LONG_ENUM_NON_ENUM_DEFAULT, 0)); + } + bool mutate_long_enum_non_enum_default(MyGame::Example::LongEnum _long_enum_non_enum_default = static_cast(0)) { + return SetField(VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast(_long_enum_non_enum_default), 0); + } + MyGame::Example::LongEnum long_enum_normal_default() const { + return static_cast(GetField(VT_LONG_ENUM_NORMAL_DEFAULT, 2ULL)); + } + bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast(2ULL)) { + return SetField(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast(_long_enum_normal_default), 2ULL); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POS, 8) && + VerifyField(verifier, VT_MANA, 2) && + VerifyField(verifier, VT_HP, 2) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_INVENTORY) && + verifier.VerifyVector(inventory()) && + VerifyField(verifier, VT_COLOR, 1) && + VerifyField(verifier, VT_TEST_TYPE, 1) && + VerifyOffset(verifier, VT_TEST) && + VerifyAny(verifier, test(), test_type()) && + VerifyOffset(verifier, VT_TEST4) && + verifier.VerifyVector(test4()) && + VerifyOffset(verifier, VT_TESTARRAYOFSTRING) && + verifier.VerifyVector(testarrayofstring()) && + verifier.VerifyVectorOfStrings(testarrayofstring()) && + VerifyOffset(verifier, VT_TESTARRAYOFTABLES) && + verifier.VerifyVector(testarrayoftables()) && + verifier.VerifyVectorOfTables(testarrayoftables()) && + VerifyOffset(verifier, VT_ENEMY) && + verifier.VerifyTable(enemy()) && + VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) && + verifier.VerifyVector(testnestedflatbuffer()) && + verifier.VerifyNestedFlatBuffer(testnestedflatbuffer(), nullptr) && + VerifyOffset(verifier, VT_TESTEMPTY) && + verifier.VerifyTable(testempty()) && + VerifyField(verifier, VT_TESTBOOL, 1) && + VerifyField(verifier, VT_TESTHASHS32_FNV1, 4) && + VerifyField(verifier, VT_TESTHASHU32_FNV1, 4) && + VerifyField(verifier, VT_TESTHASHS64_FNV1, 8) && + VerifyField(verifier, VT_TESTHASHU64_FNV1, 8) && + VerifyField(verifier, VT_TESTHASHS32_FNV1A, 4) && + VerifyField(verifier, VT_TESTHASHU32_FNV1A, 4) && + VerifyField(verifier, VT_TESTHASHS64_FNV1A, 8) && + VerifyField(verifier, VT_TESTHASHU64_FNV1A, 8) && + VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) && + verifier.VerifyVector(testarrayofbools()) && + VerifyField(verifier, VT_TESTF, 4) && + VerifyField(verifier, VT_TESTF2, 4) && + VerifyField(verifier, VT_TESTF3, 4) && + VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) && + verifier.VerifyVector(testarrayofstring2()) && + verifier.VerifyVectorOfStrings(testarrayofstring2()) && + VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) && + verifier.VerifyVector(testarrayofsortedstruct()) && + VerifyOffset(verifier, VT_FLEX) && + verifier.VerifyVector(flex()) && + flexbuffers::VerifyNestedFlexBuffer(flex(), verifier) && + VerifyOffset(verifier, VT_TEST5) && + verifier.VerifyVector(test5()) && + VerifyOffset(verifier, VT_VECTOR_OF_LONGS) && + verifier.VerifyVector(vector_of_longs()) && + VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) && + verifier.VerifyVector(vector_of_doubles()) && + VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) && + verifier.VerifyTable(parent_namespace_test()) && + VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) && + verifier.VerifyVector(vector_of_referrables()) && + verifier.VerifyVectorOfTables(vector_of_referrables()) && + VerifyField(verifier, VT_SINGLE_WEAK_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) && + verifier.VerifyVector(vector_of_weak_references()) && + VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) && + verifier.VerifyVector(vector_of_strong_referrables()) && + verifier.VerifyVectorOfTables(vector_of_strong_referrables()) && + VerifyField(verifier, VT_CO_OWNING_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) && + verifier.VerifyVector(vector_of_co_owning_references()) && + VerifyField(verifier, VT_NON_OWNING_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) && + verifier.VerifyVector(vector_of_non_owning_references()) && + VerifyField(verifier, VT_ANY_UNIQUE_TYPE, 1) && + VerifyOffset(verifier, VT_ANY_UNIQUE) && + VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) && + VerifyField(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) && + VerifyOffset(verifier, VT_ANY_AMBIGUOUS) && + VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) && + VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) && + verifier.VerifyVector(vector_of_enums()) && + VerifyField(verifier, VT_SIGNED_ENUM, 1) && + VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) && + verifier.VerifyVector(testrequirednestedflatbuffer()) && + verifier.VerifyNestedFlatBuffer(testrequirednestedflatbuffer(), nullptr) && + VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) && + verifier.VerifyVector(scalar_key_sorted_tables()) && + verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) && + VerifyField(verifier, VT_NATIVE_INLINE, 2) && + VerifyField(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) && + VerifyField(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) && + verifier.EndTable(); + } + MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +template<> inline const MyGame::Example::Monster *Monster::test_as() const { + return test_as_Monster(); +} + +template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as() const { + return test_as_TestSimpleTableWithEnum(); +} + +template<> inline const MyGame::Example2::Monster *Monster::test_as() const { + return test_as_MyGame_Example2_Monster(); +} + +template<> inline const MyGame::Example::Monster *Monster::any_unique_as() const { + return any_unique_as_M(); +} + +template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as() const { + return any_unique_as_TS(); +} + +template<> inline const MyGame::Example2::Monster *Monster::any_unique_as() const { + return any_unique_as_M2(); +} + +struct MonsterBuilder { + typedef Monster Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pos(const MyGame::Example::Vec3 *pos) { + fbb_.AddStruct(Monster::VT_POS, pos); + } + void add_mana(int16_t mana) { + fbb_.AddElement(Monster::VT_MANA, mana, 150); + } + void add_hp(int16_t hp) { + fbb_.AddElement(Monster::VT_HP, hp, 100); + } + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(Monster::VT_NAME, name); + } + void add_inventory(flatbuffers::Offset> inventory) { + fbb_.AddOffset(Monster::VT_INVENTORY, inventory); + } + void add_color(MyGame::Example::Color color) { + fbb_.AddElement(Monster::VT_COLOR, static_cast(color), 8); + } + void add_test_type(MyGame::Example::Any test_type) { + fbb_.AddElement(Monster::VT_TEST_TYPE, static_cast(test_type), 0); + } + void add_test(flatbuffers::Offset test) { + fbb_.AddOffset(Monster::VT_TEST, test); + } + void add_test4(flatbuffers::Offset> test4) { + fbb_.AddOffset(Monster::VT_TEST4, test4); + } + void add_testarrayofstring(flatbuffers::Offset>> testarrayofstring) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); + } + void add_testarrayoftables(flatbuffers::Offset>> testarrayoftables) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); + } + void add_enemy(flatbuffers::Offset enemy) { + fbb_.AddOffset(Monster::VT_ENEMY, enemy); + } + void add_testnestedflatbuffer(flatbuffers::Offset> testnestedflatbuffer) { + fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); + } + void add_testempty(flatbuffers::Offset testempty) { + fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty); + } + void add_testbool(bool testbool) { + fbb_.AddElement(Monster::VT_TESTBOOL, static_cast(testbool), 0); + } + void add_testhashs32_fnv1(int32_t testhashs32_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0); + } + void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0); + } + void add_testhashs64_fnv1(int64_t testhashs64_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0); + } + void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0); + } + void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0); + } + void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0); + } + void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0); + } + void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0); + } + void add_testarrayofbools(flatbuffers::Offset> testarrayofbools) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools); + } + void add_testf(float testf) { + fbb_.AddElement(Monster::VT_TESTF, testf, 3.14159f); + } + void add_testf2(float testf2) { + fbb_.AddElement(Monster::VT_TESTF2, testf2, 3.0f); + } + void add_testf3(float testf3) { + fbb_.AddElement(Monster::VT_TESTF3, testf3, 0.0f); + } + void add_testarrayofstring2(flatbuffers::Offset>> testarrayofstring2) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); + } + void add_testarrayofsortedstruct(flatbuffers::Offset> testarrayofsortedstruct) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); + } + void add_flex(flatbuffers::Offset> flex) { + fbb_.AddOffset(Monster::VT_FLEX, flex); + } + void add_test5(flatbuffers::Offset> test5) { + fbb_.AddOffset(Monster::VT_TEST5, test5); + } + void add_vector_of_longs(flatbuffers::Offset> vector_of_longs) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); + } + void add_vector_of_doubles(flatbuffers::Offset> vector_of_doubles) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles); + } + void add_parent_namespace_test(flatbuffers::Offset parent_namespace_test) { + fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); + } + void add_vector_of_referrables(flatbuffers::Offset>> vector_of_referrables) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables); + } + void add_single_weak_reference(uint64_t single_weak_reference) { + fbb_.AddElement(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0); + } + void add_vector_of_weak_references(flatbuffers::Offset> vector_of_weak_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references); + } + void add_vector_of_strong_referrables(flatbuffers::Offset>> vector_of_strong_referrables) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables); + } + void add_co_owning_reference(uint64_t co_owning_reference) { + fbb_.AddElement(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0); + } + void add_vector_of_co_owning_references(flatbuffers::Offset> vector_of_co_owning_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references); + } + void add_non_owning_reference(uint64_t non_owning_reference) { + fbb_.AddElement(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0); + } + void add_vector_of_non_owning_references(flatbuffers::Offset> vector_of_non_owning_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references); + } + void add_any_unique_type(MyGame::Example::AnyUniqueAliases any_unique_type) { + fbb_.AddElement(Monster::VT_ANY_UNIQUE_TYPE, static_cast(any_unique_type), 0); + } + void add_any_unique(flatbuffers::Offset any_unique) { + fbb_.AddOffset(Monster::VT_ANY_UNIQUE, any_unique); + } + void add_any_ambiguous_type(MyGame::Example::AnyAmbiguousAliases any_ambiguous_type) { + fbb_.AddElement(Monster::VT_ANY_AMBIGUOUS_TYPE, static_cast(any_ambiguous_type), 0); + } + void add_any_ambiguous(flatbuffers::Offset any_ambiguous) { + fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); + } + void add_vector_of_enums(flatbuffers::Offset> vector_of_enums) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums); + } + void add_signed_enum(MyGame::Example::Race signed_enum) { + fbb_.AddElement(Monster::VT_SIGNED_ENUM, static_cast(signed_enum), -1); + } + void add_testrequirednestedflatbuffer(flatbuffers::Offset> testrequirednestedflatbuffer) { + fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); + } + void add_scalar_key_sorted_tables(flatbuffers::Offset>> scalar_key_sorted_tables) { + fbb_.AddOffset(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); + } + void add_native_inline(const MyGame::Example::Test *native_inline) { + fbb_.AddStruct(Monster::VT_NATIVE_INLINE, native_inline); + } + void add_long_enum_non_enum_default(MyGame::Example::LongEnum long_enum_non_enum_default) { + fbb_.AddElement(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast(long_enum_non_enum_default), 0); + } + void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) { + fbb_.AddElement(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast(long_enum_normal_default), 2ULL); + } + explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Monster::VT_NAME); + return o; + } +}; + +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb, + const MyGame::Example::Vec3 *pos = nullptr, + int16_t mana = 150, + int16_t hp = 100, + flatbuffers::Offset name = 0, + flatbuffers::Offset> inventory = 0, + MyGame::Example::Color color = MyGame::Example::Color_Blue, + MyGame::Example::Any test_type = MyGame::Example::Any_NONE, + flatbuffers::Offset test = 0, + flatbuffers::Offset> test4 = 0, + flatbuffers::Offset>> testarrayofstring = 0, + flatbuffers::Offset>> testarrayoftables = 0, + flatbuffers::Offset enemy = 0, + flatbuffers::Offset> testnestedflatbuffer = 0, + flatbuffers::Offset testempty = 0, + bool testbool = false, + int32_t testhashs32_fnv1 = 0, + uint32_t testhashu32_fnv1 = 0, + int64_t testhashs64_fnv1 = 0, + uint64_t testhashu64_fnv1 = 0, + int32_t testhashs32_fnv1a = 0, + uint32_t testhashu32_fnv1a = 0, + int64_t testhashs64_fnv1a = 0, + uint64_t testhashu64_fnv1a = 0, + flatbuffers::Offset> testarrayofbools = 0, + float testf = 3.14159f, + float testf2 = 3.0f, + float testf3 = 0.0f, + flatbuffers::Offset>> testarrayofstring2 = 0, + flatbuffers::Offset> testarrayofsortedstruct = 0, + flatbuffers::Offset> flex = 0, + flatbuffers::Offset> test5 = 0, + flatbuffers::Offset> vector_of_longs = 0, + flatbuffers::Offset> vector_of_doubles = 0, + flatbuffers::Offset parent_namespace_test = 0, + flatbuffers::Offset>> vector_of_referrables = 0, + uint64_t single_weak_reference = 0, + flatbuffers::Offset> vector_of_weak_references = 0, + flatbuffers::Offset>> vector_of_strong_referrables = 0, + uint64_t co_owning_reference = 0, + flatbuffers::Offset> vector_of_co_owning_references = 0, + uint64_t non_owning_reference = 0, + flatbuffers::Offset> vector_of_non_owning_references = 0, + MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE, + flatbuffers::Offset any_unique = 0, + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE, + flatbuffers::Offset any_ambiguous = 0, + flatbuffers::Offset> vector_of_enums = 0, + MyGame::Example::Race signed_enum = MyGame::Example::Race_None, + flatbuffers::Offset> testrequirednestedflatbuffer = 0, + flatbuffers::Offset>> scalar_key_sorted_tables = 0, + const MyGame::Example::Test *native_inline = nullptr, + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0), + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) { + MonsterBuilder builder_(_fbb); + builder_.add_long_enum_normal_default(long_enum_normal_default); + builder_.add_long_enum_non_enum_default(long_enum_non_enum_default); + builder_.add_non_owning_reference(non_owning_reference); + builder_.add_co_owning_reference(co_owning_reference); + builder_.add_single_weak_reference(single_weak_reference); + builder_.add_testhashu64_fnv1a(testhashu64_fnv1a); + builder_.add_testhashs64_fnv1a(testhashs64_fnv1a); + builder_.add_testhashu64_fnv1(testhashu64_fnv1); + builder_.add_testhashs64_fnv1(testhashs64_fnv1); + builder_.add_native_inline(native_inline); + builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables); + builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer); + builder_.add_vector_of_enums(vector_of_enums); + builder_.add_any_ambiguous(any_ambiguous); + builder_.add_any_unique(any_unique); + builder_.add_vector_of_non_owning_references(vector_of_non_owning_references); + builder_.add_vector_of_co_owning_references(vector_of_co_owning_references); + builder_.add_vector_of_strong_referrables(vector_of_strong_referrables); + builder_.add_vector_of_weak_references(vector_of_weak_references); + builder_.add_vector_of_referrables(vector_of_referrables); + builder_.add_parent_namespace_test(parent_namespace_test); + builder_.add_vector_of_doubles(vector_of_doubles); + builder_.add_vector_of_longs(vector_of_longs); + builder_.add_test5(test5); + builder_.add_flex(flex); + builder_.add_testarrayofsortedstruct(testarrayofsortedstruct); + builder_.add_testarrayofstring2(testarrayofstring2); + builder_.add_testf3(testf3); + builder_.add_testf2(testf2); + builder_.add_testf(testf); + builder_.add_testarrayofbools(testarrayofbools); + builder_.add_testhashu32_fnv1a(testhashu32_fnv1a); + builder_.add_testhashs32_fnv1a(testhashs32_fnv1a); + builder_.add_testhashu32_fnv1(testhashu32_fnv1); + builder_.add_testhashs32_fnv1(testhashs32_fnv1); + builder_.add_testempty(testempty); + builder_.add_testnestedflatbuffer(testnestedflatbuffer); + builder_.add_enemy(enemy); + builder_.add_testarrayoftables(testarrayoftables); + builder_.add_testarrayofstring(testarrayofstring); + builder_.add_test4(test4); + builder_.add_test(test); + builder_.add_inventory(inventory); + builder_.add_name(name); + builder_.add_pos(pos); + builder_.add_hp(hp); + builder_.add_mana(mana); + builder_.add_signed_enum(signed_enum); + builder_.add_any_ambiguous_type(any_ambiguous_type); + builder_.add_any_unique_type(any_unique_type); + builder_.add_testbool(testbool); + builder_.add_test_type(test_type); + builder_.add_color(color); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateMonsterDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const MyGame::Example::Vec3 *pos = nullptr, + int16_t mana = 150, + int16_t hp = 100, + const char *name = nullptr, + const std::vector *inventory = nullptr, + MyGame::Example::Color color = MyGame::Example::Color_Blue, + MyGame::Example::Any test_type = MyGame::Example::Any_NONE, + flatbuffers::Offset test = 0, + const std::vector *test4 = nullptr, + const std::vector> *testarrayofstring = nullptr, + std::vector> *testarrayoftables = nullptr, + flatbuffers::Offset enemy = 0, + const std::vector *testnestedflatbuffer = nullptr, + flatbuffers::Offset testempty = 0, + bool testbool = false, + int32_t testhashs32_fnv1 = 0, + uint32_t testhashu32_fnv1 = 0, + int64_t testhashs64_fnv1 = 0, + uint64_t testhashu64_fnv1 = 0, + int32_t testhashs32_fnv1a = 0, + uint32_t testhashu32_fnv1a = 0, + int64_t testhashs64_fnv1a = 0, + uint64_t testhashu64_fnv1a = 0, + const std::vector *testarrayofbools = nullptr, + float testf = 3.14159f, + float testf2 = 3.0f, + float testf3 = 0.0f, + const std::vector> *testarrayofstring2 = nullptr, + std::vector *testarrayofsortedstruct = nullptr, + const std::vector *flex = nullptr, + const std::vector *test5 = nullptr, + const std::vector *vector_of_longs = nullptr, + const std::vector *vector_of_doubles = nullptr, + flatbuffers::Offset parent_namespace_test = 0, + std::vector> *vector_of_referrables = nullptr, + uint64_t single_weak_reference = 0, + const std::vector *vector_of_weak_references = nullptr, + std::vector> *vector_of_strong_referrables = nullptr, + uint64_t co_owning_reference = 0, + const std::vector *vector_of_co_owning_references = nullptr, + uint64_t non_owning_reference = 0, + const std::vector *vector_of_non_owning_references = nullptr, + MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE, + flatbuffers::Offset any_unique = 0, + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE, + flatbuffers::Offset any_ambiguous = 0, + const std::vector *vector_of_enums = nullptr, + MyGame::Example::Race signed_enum = MyGame::Example::Race_None, + const std::vector *testrequirednestedflatbuffer = nullptr, + std::vector> *scalar_key_sorted_tables = nullptr, + const MyGame::Example::Test *native_inline = nullptr, + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0), + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto inventory__ = inventory ? _fbb.CreateVector(*inventory) : 0; + auto test4__ = test4 ? _fbb.CreateVectorOfStructs(*test4) : 0; + auto testarrayofstring__ = testarrayofstring ? _fbb.CreateVector>(*testarrayofstring) : 0; + auto testarrayoftables__ = testarrayoftables ? _fbb.CreateVectorOfSortedTables(testarrayoftables) : 0; + auto testnestedflatbuffer__ = testnestedflatbuffer ? _fbb.CreateVector(*testnestedflatbuffer) : 0; + auto testarrayofbools__ = testarrayofbools ? _fbb.CreateVector(*testarrayofbools) : 0; + auto testarrayofstring2__ = testarrayofstring2 ? _fbb.CreateVector>(*testarrayofstring2) : 0; + auto testarrayofsortedstruct__ = testarrayofsortedstruct ? _fbb.CreateVectorOfSortedStructs(testarrayofsortedstruct) : 0; + auto flex__ = flex ? _fbb.CreateVector(*flex) : 0; + auto test5__ = test5 ? _fbb.CreateVectorOfStructs(*test5) : 0; + auto vector_of_longs__ = vector_of_longs ? _fbb.CreateVector(*vector_of_longs) : 0; + auto vector_of_doubles__ = vector_of_doubles ? _fbb.CreateVector(*vector_of_doubles) : 0; + auto vector_of_referrables__ = vector_of_referrables ? _fbb.CreateVectorOfSortedTables(vector_of_referrables) : 0; + auto vector_of_weak_references__ = vector_of_weak_references ? _fbb.CreateVector(*vector_of_weak_references) : 0; + auto vector_of_strong_referrables__ = vector_of_strong_referrables ? _fbb.CreateVectorOfSortedTables(vector_of_strong_referrables) : 0; + auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector(*vector_of_co_owning_references) : 0; + auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector(*vector_of_non_owning_references) : 0; + auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector(*vector_of_enums) : 0; + auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector(*testrequirednestedflatbuffer) : 0; + auto scalar_key_sorted_tables__ = scalar_key_sorted_tables ? _fbb.CreateVectorOfSortedTables(scalar_key_sorted_tables) : 0; + return MyGame::Example::CreateMonster( + _fbb, + pos, + mana, + hp, + name__, + inventory__, + color, + test_type, + test, + test4__, + testarrayofstring__, + testarrayoftables__, + enemy, + testnestedflatbuffer__, + testempty, + testbool, + testhashs32_fnv1, + testhashu32_fnv1, + testhashs64_fnv1, + testhashu64_fnv1, + testhashs32_fnv1a, + testhashu32_fnv1a, + testhashs64_fnv1a, + testhashu64_fnv1a, + testarrayofbools__, + testf, + testf2, + testf3, + testarrayofstring2__, + testarrayofsortedstruct__, + flex__, + test5__, + vector_of_longs__, + vector_of_doubles__, + parent_namespace_test, + vector_of_referrables__, + single_weak_reference, + vector_of_weak_references__, + vector_of_strong_referrables__, + co_owning_reference, + vector_of_co_owning_references__, + non_owning_reference, + vector_of_non_owning_references__, + any_unique_type, + any_unique, + any_ambiguous_type, + any_ambiguous, + vector_of_enums__, + signed_enum, + testrequirednestedflatbuffer__, + scalar_key_sorted_tables__, + native_inline, + long_enum_non_enum_default, + long_enum_normal_default); +} + +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct TypeAliasesT : public flatbuffers::NativeTable { + typedef TypeAliases TableType; + int8_t i8 = 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; + std::vector v8{}; + std::vector vf64{}; +}; + +struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TypeAliasesT NativeTableType; + typedef TypeAliasesBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TypeAliasesTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_I8 = 4, + VT_U8 = 6, + VT_I16 = 8, + VT_U16 = 10, + VT_I32 = 12, + VT_U32 = 14, + VT_I64 = 16, + VT_U64 = 18, + VT_F32 = 20, + VT_F64 = 22, + VT_V8 = 24, + VT_VF64 = 26 + }; + int8_t i8() const { + return GetField(VT_I8, 0); + } + bool mutate_i8(int8_t _i8 = 0) { + return SetField(VT_I8, _i8, 0); + } + uint8_t u8() const { + return GetField(VT_U8, 0); + } + bool mutate_u8(uint8_t _u8 = 0) { + return SetField(VT_U8, _u8, 0); + } + int16_t i16() const { + return GetField(VT_I16, 0); + } + bool mutate_i16(int16_t _i16 = 0) { + return SetField(VT_I16, _i16, 0); + } + uint16_t u16() const { + return GetField(VT_U16, 0); + } + bool mutate_u16(uint16_t _u16 = 0) { + return SetField(VT_U16, _u16, 0); + } + int32_t i32() const { + return GetField(VT_I32, 0); + } + bool mutate_i32(int32_t _i32 = 0) { + return SetField(VT_I32, _i32, 0); + } + uint32_t u32() const { + return GetField(VT_U32, 0); + } + bool mutate_u32(uint32_t _u32 = 0) { + return SetField(VT_U32, _u32, 0); + } + int64_t i64() const { + return GetField(VT_I64, 0); + } + bool mutate_i64(int64_t _i64 = 0) { + return SetField(VT_I64, _i64, 0); + } + uint64_t u64() const { + return GetField(VT_U64, 0); + } + bool mutate_u64(uint64_t _u64 = 0) { + return SetField(VT_U64, _u64, 0); + } + float f32() const { + return GetField(VT_F32, 0.0f); + } + bool mutate_f32(float _f32 = 0.0f) { + return SetField(VT_F32, _f32, 0.0f); + } + double f64() const { + return GetField(VT_F64, 0.0); + } + bool mutate_f64(double _f64 = 0.0) { + return SetField(VT_F64, _f64, 0.0); + } + const flatbuffers::Vector *v8() const { + return GetPointer *>(VT_V8); + } + flatbuffers::Vector *mutable_v8() { + return GetPointer *>(VT_V8); + } + const flatbuffers::Vector *vf64() const { + return GetPointer *>(VT_VF64); + } + flatbuffers::Vector *mutable_vf64() { + return GetPointer *>(VT_VF64); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_I8, 1) && + VerifyField(verifier, VT_U8, 1) && + VerifyField(verifier, VT_I16, 2) && + VerifyField(verifier, VT_U16, 2) && + VerifyField(verifier, VT_I32, 4) && + VerifyField(verifier, VT_U32, 4) && + VerifyField(verifier, VT_I64, 8) && + VerifyField(verifier, VT_U64, 8) && + VerifyField(verifier, VT_F32, 4) && + VerifyField(verifier, VT_F64, 8) && + VerifyOffset(verifier, VT_V8) && + verifier.VerifyVector(v8()) && + VerifyOffset(verifier, VT_VF64) && + verifier.VerifyVector(vf64()) && + verifier.EndTable(); + } + TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TypeAliasesBuilder { + typedef TypeAliases Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_i8(int8_t i8) { + fbb_.AddElement(TypeAliases::VT_I8, i8, 0); + } + void add_u8(uint8_t u8) { + fbb_.AddElement(TypeAliases::VT_U8, u8, 0); + } + void add_i16(int16_t i16) { + fbb_.AddElement(TypeAliases::VT_I16, i16, 0); + } + void add_u16(uint16_t u16) { + fbb_.AddElement(TypeAliases::VT_U16, u16, 0); + } + void add_i32(int32_t i32) { + fbb_.AddElement(TypeAliases::VT_I32, i32, 0); + } + void add_u32(uint32_t u32) { + fbb_.AddElement(TypeAliases::VT_U32, u32, 0); + } + void add_i64(int64_t i64) { + fbb_.AddElement(TypeAliases::VT_I64, i64, 0); + } + void add_u64(uint64_t u64) { + fbb_.AddElement(TypeAliases::VT_U64, u64, 0); + } + void add_f32(float f32) { + fbb_.AddElement(TypeAliases::VT_F32, f32, 0.0f); + } + void add_f64(double f64) { + fbb_.AddElement(TypeAliases::VT_F64, f64, 0.0); + } + void add_v8(flatbuffers::Offset> v8) { + fbb_.AddOffset(TypeAliases::VT_V8, v8); + } + void add_vf64(flatbuffers::Offset> vf64) { + fbb_.AddOffset(TypeAliases::VT_VF64, vf64); + } + explicit TypeAliasesBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTypeAliases( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + flatbuffers::Offset> v8 = 0, + flatbuffers::Offset> vf64 = 0) { + TypeAliasesBuilder builder_(_fbb); + builder_.add_f64(f64); + builder_.add_u64(u64); + builder_.add_i64(i64); + builder_.add_vf64(vf64); + builder_.add_v8(v8); + builder_.add_f32(f32); + builder_.add_u32(u32); + builder_.add_i32(i32); + builder_.add_u16(u16); + builder_.add_i16(i16); + builder_.add_u8(u8); + builder_.add_i8(i8); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTypeAliasesDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + const std::vector *v8 = nullptr, + const std::vector *vf64 = nullptr) { + auto v8__ = v8 ? _fbb.CreateVector(*v8) : 0; + auto vf64__ = vf64 ? _fbb.CreateVector(*vf64) : 0; + return MyGame::Example::CreateTypeAliases( + _fbb, + i8, + u8, + i16, + u16, + i32, + u32, + i64, + u64, + f32, + f64, + v8__, + vf64__); +} + +flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +} // namespace Example + + +inline bool operator==(const InParentNamespaceT &, const InParentNamespaceT &) { + return true; +} + +inline bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs) { + return !(lhs == rhs); +} + + +inline InParentNamespaceT *InParentNamespace::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new InParentNamespaceT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; +} + +inline flatbuffers::Offset InParentNamespace::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateInParentNamespace(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InParentNamespaceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return MyGame::CreateInParentNamespace( + _fbb); +} + +namespace Example2 { + + +inline bool operator==(const MonsterT &, const MonsterT &) { + return true; +} + +inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { + return !(lhs == rhs); +} + + +inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new MonsterT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; +} + +inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateMonster(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return MyGame::Example2::CreateMonster( + _fbb); +} + +} // namespace Example2 + +namespace Example { + + +inline bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { + return + (lhs.color == rhs.color); +} + +inline bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { + return !(lhs == rhs); +} + + +inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new TestSimpleTableWithEnumT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = color(); _o->color = _e; } +} + +inline flatbuffers::Offset TestSimpleTableWithEnum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TestSimpleTableWithEnumT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _color = _o->color; + return MyGame::Example::CreateTestSimpleTableWithEnum( + _fbb, + _color); +} + + +inline bool operator==(const StatT &lhs, const StatT &rhs) { + return + (lhs.id == rhs.id) && + (lhs.val == rhs.val) && + (lhs.count == rhs.count); +} + +inline bool operator!=(const StatT &lhs, const StatT &rhs) { + return !(lhs == rhs); +} + + +inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new StatT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Stat::UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); if (_e) _o->id = _e->str(); } + { auto _e = val(); _o->val = _e; } + { auto _e = count(); _o->count = _e; } +} + +inline flatbuffers::Offset Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateStat(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id.empty() ? 0 : _fbb.CreateString(_o->id); + auto _val = _o->val; + auto _count = _o->count; + return MyGame::Example::CreateStat( + _fbb, + _id, + _val, + _count); +} + + +inline bool operator==(const ReferrableT &lhs, const ReferrableT &rhs) { + return + (lhs.id == rhs.id); +} + +inline bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs) { + return !(lhs == rhs); +} + + +inline ReferrableT *Referrable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ReferrableT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Referrable::UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); _o->id = _e; } +} + +inline flatbuffers::Offset Referrable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateReferrable(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id; + return MyGame::Example::CreateReferrable( + _fbb, + _id); +} + + +inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) { + return + ((lhs.pos == rhs.pos) || (lhs.pos && rhs.pos && *lhs.pos == *rhs.pos)) && + (lhs.mana == rhs.mana) && + (lhs.hp == rhs.hp) && + (lhs.name == rhs.name) && + (lhs.inventory == rhs.inventory) && + (lhs.color == rhs.color) && + (lhs.test == rhs.test) && + (lhs.test4 == rhs.test4) && + (lhs.testarrayofstring == rhs.testarrayofstring) && + (lhs.testarrayoftables == rhs.testarrayoftables) && + ((lhs.enemy == rhs.enemy) || (lhs.enemy && rhs.enemy && *lhs.enemy == *rhs.enemy)) && + (lhs.testnestedflatbuffer == rhs.testnestedflatbuffer) && + ((lhs.testempty == rhs.testempty) || (lhs.testempty && rhs.testempty && *lhs.testempty == *rhs.testempty)) && + (lhs.testbool == rhs.testbool) && + (lhs.testhashs32_fnv1 == rhs.testhashs32_fnv1) && + (lhs.testhashu32_fnv1 == rhs.testhashu32_fnv1) && + (lhs.testhashs64_fnv1 == rhs.testhashs64_fnv1) && + (lhs.testhashu64_fnv1 == rhs.testhashu64_fnv1) && + (lhs.testhashs32_fnv1a == rhs.testhashs32_fnv1a) && + (lhs.testhashu32_fnv1a == rhs.testhashu32_fnv1a) && + (lhs.testhashs64_fnv1a == rhs.testhashs64_fnv1a) && + (lhs.testhashu64_fnv1a == rhs.testhashu64_fnv1a) && + (lhs.testarrayofbools == rhs.testarrayofbools) && + (lhs.testf == rhs.testf) && + (lhs.testf2 == rhs.testf2) && + (lhs.testf3 == rhs.testf3) && + (lhs.testarrayofstring2 == rhs.testarrayofstring2) && + (lhs.testarrayofsortedstruct == rhs.testarrayofsortedstruct) && + (lhs.flex == rhs.flex) && + (lhs.test5 == rhs.test5) && + (lhs.vector_of_longs == rhs.vector_of_longs) && + (lhs.vector_of_doubles == rhs.vector_of_doubles) && + ((lhs.parent_namespace_test == rhs.parent_namespace_test) || (lhs.parent_namespace_test && rhs.parent_namespace_test && *lhs.parent_namespace_test == *rhs.parent_namespace_test)) && + (lhs.vector_of_referrables == rhs.vector_of_referrables) && + (lhs.single_weak_reference == rhs.single_weak_reference) && + (lhs.vector_of_weak_references == rhs.vector_of_weak_references) && + (lhs.vector_of_strong_referrables == rhs.vector_of_strong_referrables) && + (lhs.co_owning_reference == rhs.co_owning_reference) && + (lhs.vector_of_co_owning_references == rhs.vector_of_co_owning_references) && + (lhs.non_owning_reference == rhs.non_owning_reference) && + (lhs.vector_of_non_owning_references == rhs.vector_of_non_owning_references) && + (lhs.any_unique == rhs.any_unique) && + (lhs.any_ambiguous == rhs.any_ambiguous) && + (lhs.vector_of_enums == rhs.vector_of_enums) && + (lhs.signed_enum == rhs.signed_enum) && + (lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer) && + (lhs.scalar_key_sorted_tables == rhs.scalar_key_sorted_tables) && + (lhs.native_inline == rhs.native_inline) && + (lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) && + (lhs.long_enum_normal_default == rhs.long_enum_normal_default); +} + +inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { + return !(lhs == rhs); +} + + +inline MonsterT::MonsterT(const MonsterT &o) + : pos((o.pos) ? new MyGame::Example::Vec3(*o.pos) : nullptr), + mana(o.mana), + hp(o.hp), + name(o.name), + inventory(o.inventory), + color(o.color), + test(o.test), + test4(o.test4), + testarrayofstring(o.testarrayofstring), + enemy((o.enemy) ? new MyGame::Example::MonsterT(*o.enemy) : nullptr), + testnestedflatbuffer(o.testnestedflatbuffer), + testempty((o.testempty) ? new MyGame::Example::StatT(*o.testempty) : nullptr), + testbool(o.testbool), + testhashs32_fnv1(o.testhashs32_fnv1), + testhashu32_fnv1(o.testhashu32_fnv1), + testhashs64_fnv1(o.testhashs64_fnv1), + testhashu64_fnv1(o.testhashu64_fnv1), + testhashs32_fnv1a(o.testhashs32_fnv1a), + testhashu32_fnv1a(o.testhashu32_fnv1a), + testhashs64_fnv1a(o.testhashs64_fnv1a), + testhashu64_fnv1a(o.testhashu64_fnv1a), + testarrayofbools(o.testarrayofbools), + testf(o.testf), + testf2(o.testf2), + testf3(o.testf3), + testarrayofstring2(o.testarrayofstring2), + testarrayofsortedstruct(o.testarrayofsortedstruct), + flex(o.flex), + test5(o.test5), + vector_of_longs(o.vector_of_longs), + vector_of_doubles(o.vector_of_doubles), + parent_namespace_test((o.parent_namespace_test) ? new MyGame::InParentNamespaceT(*o.parent_namespace_test) : nullptr), + single_weak_reference(o.single_weak_reference), + vector_of_weak_references(o.vector_of_weak_references), + co_owning_reference(o.co_owning_reference), + non_owning_reference(o.non_owning_reference), + vector_of_non_owning_references(o.vector_of_non_owning_references), + any_unique(o.any_unique), + any_ambiguous(o.any_ambiguous), + vector_of_enums(o.vector_of_enums), + signed_enum(o.signed_enum), + testrequirednestedflatbuffer(o.testrequirednestedflatbuffer), + native_inline(o.native_inline), + long_enum_non_enum_default(o.long_enum_non_enum_default), + long_enum_normal_default(o.long_enum_normal_default) { + testarrayoftables.reserve(o.testarrayoftables.size()); + for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); } + vector_of_referrables.reserve(o.vector_of_referrables.size()); + for (const auto &vector_of_referrables_ : o.vector_of_referrables) { vector_of_referrables.emplace_back((vector_of_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_referrables_) : nullptr); } + vector_of_strong_referrables.reserve(o.vector_of_strong_referrables.size()); + for (const auto &vector_of_strong_referrables_ : o.vector_of_strong_referrables) { vector_of_strong_referrables.emplace_back((vector_of_strong_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_strong_referrables_) : nullptr); } + vector_of_co_owning_references.reserve(o.vector_of_co_owning_references.size()); + for (const auto &vector_of_co_owning_references_ : o.vector_of_co_owning_references) { vector_of_co_owning_references.emplace_back((vector_of_co_owning_references_) ? new ReferrableT(*vector_of_co_owning_references_) : nullptr); } + scalar_key_sorted_tables.reserve(o.scalar_key_sorted_tables.size()); + for (const auto &scalar_key_sorted_tables_ : o.scalar_key_sorted_tables) { scalar_key_sorted_tables.emplace_back((scalar_key_sorted_tables_) ? new MyGame::Example::StatT(*scalar_key_sorted_tables_) : nullptr); } +} + +inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT { + std::swap(pos, o.pos); + std::swap(mana, o.mana); + std::swap(hp, o.hp); + std::swap(name, o.name); + std::swap(inventory, o.inventory); + std::swap(color, o.color); + std::swap(test, o.test); + std::swap(test4, o.test4); + std::swap(testarrayofstring, o.testarrayofstring); + std::swap(testarrayoftables, o.testarrayoftables); + std::swap(enemy, o.enemy); + std::swap(testnestedflatbuffer, o.testnestedflatbuffer); + std::swap(testempty, o.testempty); + std::swap(testbool, o.testbool); + std::swap(testhashs32_fnv1, o.testhashs32_fnv1); + std::swap(testhashu32_fnv1, o.testhashu32_fnv1); + std::swap(testhashs64_fnv1, o.testhashs64_fnv1); + std::swap(testhashu64_fnv1, o.testhashu64_fnv1); + std::swap(testhashs32_fnv1a, o.testhashs32_fnv1a); + std::swap(testhashu32_fnv1a, o.testhashu32_fnv1a); + std::swap(testhashs64_fnv1a, o.testhashs64_fnv1a); + std::swap(testhashu64_fnv1a, o.testhashu64_fnv1a); + std::swap(testarrayofbools, o.testarrayofbools); + std::swap(testf, o.testf); + std::swap(testf2, o.testf2); + std::swap(testf3, o.testf3); + std::swap(testarrayofstring2, o.testarrayofstring2); + std::swap(testarrayofsortedstruct, o.testarrayofsortedstruct); + std::swap(flex, o.flex); + std::swap(test5, o.test5); + std::swap(vector_of_longs, o.vector_of_longs); + std::swap(vector_of_doubles, o.vector_of_doubles); + std::swap(parent_namespace_test, o.parent_namespace_test); + std::swap(vector_of_referrables, o.vector_of_referrables); + std::swap(single_weak_reference, o.single_weak_reference); + std::swap(vector_of_weak_references, o.vector_of_weak_references); + std::swap(vector_of_strong_referrables, o.vector_of_strong_referrables); + std::swap(co_owning_reference, o.co_owning_reference); + std::swap(vector_of_co_owning_references, o.vector_of_co_owning_references); + std::swap(non_owning_reference, o.non_owning_reference); + std::swap(vector_of_non_owning_references, o.vector_of_non_owning_references); + std::swap(any_unique, o.any_unique); + std::swap(any_ambiguous, o.any_ambiguous); + std::swap(vector_of_enums, o.vector_of_enums); + std::swap(signed_enum, o.signed_enum); + std::swap(testrequirednestedflatbuffer, o.testrequirednestedflatbuffer); + std::swap(scalar_key_sorted_tables, o.scalar_key_sorted_tables); + std::swap(native_inline, o.native_inline); + std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default); + std::swap(long_enum_normal_default, o.long_enum_normal_default); + return *this; +} + +inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new MonsterT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr(new MyGame::Example::Vec3(*_e)); } + { auto _e = mana(); _o->mana = _e; } + { auto _e = hp(); _o->hp = _e; } + { auto _e = name(); if (_e) _o->name = _e->str(); } + { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } } + { auto _e = color(); _o->color = _e; } + { auto _e = test_type(); _o->test.type = _e; } + { auto _e = test(); if (_e) _o->test.value = MyGame::Example::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++) { if(_o->testarrayoftables[_i]) { _e->Get(_i)->UnPackTo(_o->testarrayoftables[_i].get(), _resolver); } else { _o->testarrayoftables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = enemy(); if (_e) { if(_o->enemy) { _e->UnPackTo(_o->enemy.get(), _resolver); } else { _o->enemy = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testnestedflatbuffer.begin()); } } + { auto _e = testempty(); if (_e) { if(_o->testempty) { _e->UnPackTo(_o->testempty.get(), _resolver); } else { _o->testempty = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = testbool(); _o->testbool = _e; } + { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; } + { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; } + { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; } + { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; } + { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; } + { auto _e = testhashu32_fnv1a(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->testhashu32_fnv1a), static_cast(_e)); else _o->testhashu32_fnv1a = nullptr; } + { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; } + { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; } + { auto _e = testarrayofbools(); if (_e) { _o->testarrayofbools.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools[_i] = _e->Get(_i) != 0; } } } + { auto _e = testf(); _o->testf = _e; } + { auto _e = testf2(); _o->testf2 = _e; } + { auto _e = testf3(); _o->testf3 = _e; } + { auto _e = testarrayofstring2(); if (_e) { _o->testarrayofstring2.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2[_i] = _e->Get(_i)->str(); } } } + { auto _e = testarrayofsortedstruct(); if (_e) { _o->testarrayofsortedstruct.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofsortedstruct[_i] = *_e->Get(_i); } } } + { auto _e = flex(); if (_e) { _o->flex.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->flex.begin()); } } + { auto _e = test5(); if (_e) { _o->test5.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test5[_i] = *_e->Get(_i); } } } + { auto _e = vector_of_longs(); if (_e) { _o->vector_of_longs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_longs[_i] = _e->Get(_i); } } } + { auto _e = vector_of_doubles(); if (_e) { _o->vector_of_doubles.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_doubles[_i] = _e->Get(_i); } } } + { auto _e = parent_namespace_test(); if (_e) { if(_o->parent_namespace_test) { _e->UnPackTo(_o->parent_namespace_test.get(), _resolver); } else { _o->parent_namespace_test = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = vector_of_referrables(); if (_e) { _o->vector_of_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_referrables[_i].get(), _resolver); } else { _o->vector_of_referrables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = single_weak_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->single_weak_reference), static_cast(_e)); else _o->single_weak_reference = nullptr; } + { auto _e = vector_of_weak_references(); if (_e) { _o->vector_of_weak_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_weak_references[_i]), static_cast(_e->Get(_i))); else _o->vector_of_weak_references[_i] = nullptr; } } } + { auto _e = vector_of_strong_referrables(); if (_e) { _o->vector_of_strong_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_strong_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_strong_referrables[_i].get(), _resolver); } else { _o->vector_of_strong_referrables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = co_owning_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->co_owning_reference), static_cast(_e)); else _o->co_owning_reference = nullptr; } + { auto _e = vector_of_co_owning_references(); if (_e) { _o->vector_of_co_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, default_ptr_type +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_co_owning_references[_i]), static_cast(_e->Get(_i)));/* else do nothing */; } } } + { auto _e = non_owning_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->non_owning_reference), static_cast(_e)); else _o->non_owning_reference = nullptr; } + { auto _e = vector_of_non_owning_references(); if (_e) { _o->vector_of_non_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_non_owning_references[_i]), static_cast(_e->Get(_i))); else _o->vector_of_non_owning_references[_i] = nullptr; } } } + { auto _e = any_unique_type(); _o->any_unique.type = _e; } + { auto _e = any_unique(); if (_e) _o->any_unique.value = MyGame::Example::AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); } + { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; } + { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); } + { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast(_e->Get(_i)); } } } + { auto _e = signed_enum(); _o->signed_enum = _e; } + { auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } } + { auto _e = scalar_key_sorted_tables(); if (_e) { _o->scalar_key_sorted_tables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->scalar_key_sorted_tables[_i]) { _e->Get(_i)->UnPackTo(_o->scalar_key_sorted_tables[_i].get(), _resolver); } else { _o->scalar_key_sorted_tables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = native_inline(); if (_e) _o->native_inline = *_e; } + { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; } + { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; } +} + +inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateMonster(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _pos = _o->pos ? _o->pos.get() : 0; + auto _mana = _o->mana; + auto _hp = _o->hp; + auto _name = _fbb.CreateString(_o->name); + auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0; + auto _color = _o->color; + auto _test_type = _o->test.type; + auto _test = _o->test.Pack(_fbb); + auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0; + auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0; + auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0; + auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0; + auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0; + auto _testbool = _o->testbool; + auto _testhashs32_fnv1 = _o->testhashs32_fnv1; + auto _testhashu32_fnv1 = _o->testhashu32_fnv1; + auto _testhashs64_fnv1 = _o->testhashs64_fnv1; + auto _testhashu64_fnv1 = _o->testhashu64_fnv1; + auto _testhashs32_fnv1a = _o->testhashs32_fnv1a; + auto _testhashu32_fnv1a = _rehasher ? static_cast((*_rehasher)(_o->testhashu32_fnv1a)) : 0; + auto _testhashs64_fnv1a = _o->testhashs64_fnv1a; + auto _testhashu64_fnv1a = _o->testhashu64_fnv1a; + auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0; + auto _testf = _o->testf; + auto _testf2 = _o->testf2; + auto _testf3 = _o->testf3; + auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0; + auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0; + auto _flex = _o->flex.size() ? _fbb.CreateVector(_o->flex) : 0; + auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0; + auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0; + auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0; + auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0; + auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _single_weak_reference = _rehasher ? static_cast((*_rehasher)(_o->single_weak_reference)) : 0; + auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0; + auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _co_owning_reference = _rehasher ? static_cast((*_rehasher)(_o->co_owning_reference)) : 0; + auto _vector_of_co_owning_references = _o->vector_of_co_owning_references.size() ? _fbb.CreateVector(_o->vector_of_co_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_co_owning_references[i].get())) : 0; }, &_va ) : 0; + auto _non_owning_reference = _rehasher ? static_cast((*_rehasher)(_o->non_owning_reference)) : 0; + auto _vector_of_non_owning_references = _o->vector_of_non_owning_references.size() ? _fbb.CreateVector(_o->vector_of_non_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_non_owning_references[i])) : 0; }, &_va ) : 0; + auto _any_unique_type = _o->any_unique.type; + auto _any_unique = _o->any_unique.Pack(_fbb); + auto _any_ambiguous_type = _o->any_ambiguous.type; + auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb); + auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast(flatbuffers::data(_o->vector_of_enums), _o->vector_of_enums.size()) : 0; + auto _signed_enum = _o->signed_enum; + auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0; + auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _native_inline = &_o->native_inline; + auto _long_enum_non_enum_default = _o->long_enum_non_enum_default; + auto _long_enum_normal_default = _o->long_enum_normal_default; + return MyGame::Example::CreateMonster( + _fbb, + _pos, + _mana, + _hp, + _name, + _inventory, + _color, + _test_type, + _test, + _test4, + _testarrayofstring, + _testarrayoftables, + _enemy, + _testnestedflatbuffer, + _testempty, + _testbool, + _testhashs32_fnv1, + _testhashu32_fnv1, + _testhashs64_fnv1, + _testhashu64_fnv1, + _testhashs32_fnv1a, + _testhashu32_fnv1a, + _testhashs64_fnv1a, + _testhashu64_fnv1a, + _testarrayofbools, + _testf, + _testf2, + _testf3, + _testarrayofstring2, + _testarrayofsortedstruct, + _flex, + _test5, + _vector_of_longs, + _vector_of_doubles, + _parent_namespace_test, + _vector_of_referrables, + _single_weak_reference, + _vector_of_weak_references, + _vector_of_strong_referrables, + _co_owning_reference, + _vector_of_co_owning_references, + _non_owning_reference, + _vector_of_non_owning_references, + _any_unique_type, + _any_unique, + _any_ambiguous_type, + _any_ambiguous, + _vector_of_enums, + _signed_enum, + _testrequirednestedflatbuffer, + _scalar_key_sorted_tables, + _native_inline, + _long_enum_non_enum_default, + _long_enum_normal_default); +} + + +inline bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { + return + (lhs.i8 == rhs.i8) && + (lhs.u8 == rhs.u8) && + (lhs.i16 == rhs.i16) && + (lhs.u16 == rhs.u16) && + (lhs.i32 == rhs.i32) && + (lhs.u32 == rhs.u32) && + (lhs.i64 == rhs.i64) && + (lhs.u64 == rhs.u64) && + (lhs.f32 == rhs.f32) && + (lhs.f64 == rhs.f64) && + (lhs.v8 == rhs.v8) && + (lhs.vf64 == rhs.vf64); +} + +inline bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { + return !(lhs == rhs); +} + + +inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new TypeAliasesT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +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()); std::copy(_e->begin(), _e->end(), _o->v8.begin()); } } + { auto _e = vf64(); if (_e) { _o->vf64.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vf64[_i] = _e->Get(_i); } } } +} + +inline flatbuffers::Offset TypeAliases::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTypeAliases(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _i8 = _o->i8; + auto _u8 = _o->u8; + auto _i16 = _o->i16; + auto _u16 = _o->u16; + auto _i32 = _o->i32; + auto _u32 = _o->u32; + auto _i64 = _o->i64; + auto _u64 = _o->u64; + auto _f32 = _o->f32; + auto _f64 = _o->f64; + auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0; + auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0; + return MyGame::Example::CreateTypeAliases( + _fbb, + _i8, + _u8, + _i16, + _u16, + _i32, + _u32, + _i64, + _u64, + _f32, + _f64, + _v8, + _vf64); +} + +inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) { + switch (type) { + case Any_NONE: { + return true; + } + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAny( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(value); + return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyUnion::AnyUnion(const AnyUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case Any_Monster: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case Any_TestSimpleTableWithEnum: { + value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast(u.value)); + break; + } + case Any_MyGame_Example2_Monster: { + value = new MyGame::Example2::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyUnion::Reset() { + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = Any_NONE; +} + +inline bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) { + switch (type) { + case AnyUniqueAliases_NONE: { + return true; + } + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAnyUniqueAliases( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyUniqueAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(value); + return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case AnyUniqueAliases_M: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyUniqueAliases_TS: { + value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast(u.value)); + break; + } + case AnyUniqueAliases_M2: { + value = new MyGame::Example2::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyUniqueAliasesUnion::Reset() { + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = AnyUniqueAliases_NONE; +} + +inline bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) { + switch (type) { + case AnyAmbiguousAliases_NONE: { + return true; + } + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAnyAmbiguousAliases( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyAmbiguousAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case AnyAmbiguousAliases_M1: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyAmbiguousAliases_M2: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyAmbiguousAliases_M3: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyAmbiguousAliasesUnion::Reset() { + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = AnyAmbiguousAliases_NONE; +} + +inline const flatbuffers::TypeTable *ColorTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_UCHAR, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable + }; + static const int64_t values[] = { 1, 2, 8 }; + static const char * const names[] = { + "Red", + "Green", + "Blue" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *RaceTypeTable() { + 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 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::RaceTypeTable + }; + static const int64_t values[] = { -1, 0, 1, 2 }; + static const char * const names[] = { + "None", + "Human", + "Dwarf", + "Elf" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *LongEnumTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_ULONG, 0, 0 }, + { flatbuffers::ET_ULONG, 0, 0 }, + { flatbuffers::ET_ULONG, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::LongEnumTypeTable + }; + static const int64_t values[] = { 2ULL, 4ULL, 1099511627776ULL }; + static const char * const names[] = { + "LongOne", + "LongTwo", + "LongBig" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 2 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable, + MyGame::Example::TestSimpleTableWithEnumTypeTable, + MyGame::Example2::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "Monster", + "TestSimpleTableWithEnum", + "MyGame_Example2_Monster" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 2 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable, + MyGame::Example::TestSimpleTableWithEnumTypeTable, + MyGame::Example2::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "M", + "TS", + "M2" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "M1", + "M2", + "M3" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +} // namespace Example + +inline const flatbuffers::TypeTable *InParentNamespaceTypeTable() { + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr + }; + return &tt; +} + +namespace Example2 { + +inline const flatbuffers::TypeTable *MonsterTypeTable() { + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr + }; + return &tt; +} + +} // namespace Example2 + +namespace Example { + +inline const flatbuffers::TypeTable *TestTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_CHAR, 0, -1 } + }; + static const int64_t values[] = { 0, 2, 4 }; + static const char * const names[] = { + "a", + "b" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UCHAR, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable + }; + static const char * const names[] = { + "color" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *Vec3TypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_DOUBLE, 0, -1 }, + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable, + MyGame::Example::TestTypeTable + }; + static const int64_t values[] = { 0, 4, 8, 16, 24, 26, 32 }; + static const char * const names[] = { + "x", + "y", + "z", + "test1", + "test2", + "test3" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 6, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AbilityTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8 }; + static const char * const names[] = { + "id", + "distance" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StructOfStructsTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::AbilityTypeTable, + MyGame::Example::TestTypeTable + }; + static const int64_t values[] = { 0, 8, 12, 20 }; + static const char * const names[] = { + "a", + "b", + "c" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::StructOfStructsTypeTable + }; + static const int64_t values[] = { 0, 20 }; + static const char * const names[] = { + "a" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 1, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StatTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_STRING, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_USHORT, 0, -1 } + }; + static const char * const names[] = { + "id", + "val", + "count" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *ReferrableTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_ULONG, 0, -1 } + }; + static const char * const names[] = { + "id" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *MonsterTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_STRING, 0, -1 }, + { flatbuffers::ET_BOOL, 0, -1 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_UCHAR, 0, 1 }, + { flatbuffers::ET_UTYPE, 0, 2 }, + { flatbuffers::ET_SEQUENCE, 0, 2 }, + { flatbuffers::ET_SEQUENCE, 1, 3 }, + { flatbuffers::ET_STRING, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 4 }, + { flatbuffers::ET_SEQUENCE, 0, 4 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 5 }, + { flatbuffers::ET_BOOL, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_BOOL, 1, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_STRING, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 6 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 3 }, + { flatbuffers::ET_LONG, 1, -1 }, + { flatbuffers::ET_DOUBLE, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 7 }, + { flatbuffers::ET_SEQUENCE, 1, 8 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 8 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_UTYPE, 0, 9 }, + { flatbuffers::ET_SEQUENCE, 0, 9 }, + { flatbuffers::ET_UTYPE, 0, 10 }, + { flatbuffers::ET_SEQUENCE, 0, 10 }, + { flatbuffers::ET_UCHAR, 1, 1 }, + { flatbuffers::ET_CHAR, 0, 11 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 5 }, + { flatbuffers::ET_SEQUENCE, 0, 3 }, + { flatbuffers::ET_ULONG, 0, 12 }, + { flatbuffers::ET_ULONG, 0, 12 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::Vec3TypeTable, + MyGame::Example::ColorTypeTable, + MyGame::Example::AnyTypeTable, + MyGame::Example::TestTypeTable, + MyGame::Example::MonsterTypeTable, + MyGame::Example::StatTypeTable, + MyGame::Example::AbilityTypeTable, + MyGame::InParentNamespaceTypeTable, + MyGame::Example::ReferrableTypeTable, + MyGame::Example::AnyUniqueAliasesTypeTable, + MyGame::Example::AnyAmbiguousAliasesTypeTable, + MyGame::Example::RaceTypeTable, + MyGame::Example::LongEnumTypeTable + }; + static const char * const names[] = { + "pos", + "mana", + "hp", + "name", + "friendly", + "inventory", + "color", + "test_type", + "test", + "test4", + "testarrayofstring", + "testarrayoftables", + "enemy", + "testnestedflatbuffer", + "testempty", + "testbool", + "testhashs32_fnv1", + "testhashu32_fnv1", + "testhashs64_fnv1", + "testhashu64_fnv1", + "testhashs32_fnv1a", + "testhashu32_fnv1a", + "testhashs64_fnv1a", + "testhashu64_fnv1a", + "testarrayofbools", + "testf", + "testf2", + "testf3", + "testarrayofstring2", + "testarrayofsortedstruct", + "flex", + "test5", + "vector_of_longs", + "vector_of_doubles", + "parent_namespace_test", + "vector_of_referrables", + "single_weak_reference", + "vector_of_weak_references", + "vector_of_strong_referrables", + "co_owning_reference", + "vector_of_co_owning_references", + "non_owning_reference", + "vector_of_non_owning_references", + "any_unique_type", + "any_unique", + "any_ambiguous_type", + "any_ambiguous", + "vector_of_enums", + "signed_enum", + "testrequirednestedflatbuffer", + "scalar_key_sorted_tables", + "native_inline", + "long_enum_non_enum_default", + "long_enum_normal_default" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *TypeAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_CHAR, 0, -1 }, + { flatbuffers::ET_UCHAR, 0, -1 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_USHORT, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_DOUBLE, 0, -1 }, + { flatbuffers::ET_CHAR, 1, -1 }, + { flatbuffers::ET_DOUBLE, 1, -1 } + }; + static const char * const names[] = { + "i8", + "u8", + "i16", + "u16", + "i32", + "u32", + "i64", + "u64", + "f32", + "f64", + "v8", + "vf64" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const MyGame::Example::Monster *GetMonster(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline Monster *GetMutableMonster(void *buf) { + return flatbuffers::GetMutableRoot(buf); +} + +inline MyGame::Example::Monster *GetMutableSizePrefixedMonster(void *buf) { + return flatbuffers::GetMutableSizePrefixedRoot(buf); +} + +inline const char *MonsterIdentifier() { + return "MONS"; +} + +inline bool MonsterBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, MonsterIdentifier()); +} + +inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, MonsterIdentifier(), true); +} + +inline bool VerifyMonsterBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(MonsterIdentifier()); +} + +inline bool VerifySizePrefixedMonsterBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(MonsterIdentifier()); +} + +inline const char *MonsterExtension() { + return "mon"; +} + +inline void FinishMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root, MonsterIdentifier()); +} + +inline void FinishSizePrefixedMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root, MonsterIdentifier()); +} + +inline flatbuffers::unique_ptr UnPackMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr(GetMonster(buf)->UnPack(res)); +} + +inline flatbuffers::unique_ptr UnPackSizePrefixedMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr(GetSizePrefixedMonster(buf)->UnPack(res)); +} + +} // namespace Example +} // namespace MyGame + +#endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ diff --git a/tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.cc b/tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.cc new file mode 100644 index 000000000..3ef89ceeb --- /dev/null +++ b/tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.cc @@ -0,0 +1,131 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: monster_test + +#include "monster_test_suffix.h" +#include "monster_test.grpc.fb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +namespace MyGame { +namespace Example { + +static const char* MonsterStorage_method_names[] = { + "/MyGame.Example.MonsterStorage/Store", + "/MyGame.Example.MonsterStorage/Retrieve", + "/MyGame.Example.MonsterStorage/GetMaxHitPoint", + "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints", +}; + +std::unique_ptr< MonsterStorage::Stub> MonsterStorage::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& /*options*/) { + std::unique_ptr< MonsterStorage::Stub> stub(new MonsterStorage::Stub(channel)); + return stub; +} + +MonsterStorage::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) + : channel_(channel) , rpcmethod_Store_(MonsterStorage_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Retrieve_(MonsterStorage_method_names[1], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + , rpcmethod_GetMaxHitPoint_(MonsterStorage_method_names[2], ::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) + , rpcmethod_GetMinMaxHitPoints_(MonsterStorage_method_names[3], ::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + {} + +::grpc::Status MonsterStorage::Stub::Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Store_, context, request, response); +} + +::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, false); +} + +::grpc::ClientReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return ::grpc::internal::ClientReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_Retrieve_, context, request); +} + +::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, false, nullptr); +} + +::grpc::ClientWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return ::grpc::internal::ClientWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_GetMaxHitPoint_, context, response); +} + +::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMaxHitPoint_, context, response, true, tag); +} + +::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMaxHitPoint_, context, response, false, nullptr); +} + +::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::GetMinMaxHitPointsRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_GetMinMaxHitPoints_, context); +} + +::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMinMaxHitPoints_, context, true, tag); +} + +::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMinMaxHitPoints_, context, false, nullptr); +} + +MonsterStorage::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::Store), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[1], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::Retrieve), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[2], + ::grpc::internal::RpcMethod::CLIENT_STREAMING, + new ::grpc::internal::ClientStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::GetMaxHitPoint), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[3], + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::GetMinMaxHitPoints), this))); +} + +MonsterStorage::Service::~Service() { +} + +::grpc::Status MonsterStorage::Service::Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* /*response*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +} // namespace MyGame +} // namespace Example + diff --git a/tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.h b/tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.h new file mode 100644 index 000000000..77d796d9a --- /dev/null +++ b/tests/monster_test_suffix/filesuffix_only/monster_test.grpc.fb.h @@ -0,0 +1,350 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: monster_test +#ifndef GRPC_monster_5ftest__INCLUDED +#define GRPC_monster_5ftest__INCLUDED + +#include "monster_test_suffix.h" +#include "flatbuffers/grpc.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace grpc { +class CompletionQueue; +class Channel; +class ServerCompletionQueue; +class ServerContext; +} // namespace grpc + +namespace MyGame { +namespace Example { + +class MonsterStorage final { + public: + static constexpr char const* service_full_name() { + return "MyGame.Example.MonsterStorage"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + virtual ::grpc::Status Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>> GetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return std::unique_ptr< ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>>(GetMaxHitPointRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>> AsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>>(AsyncGetMaxHitPointRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>> PrepareAsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>>(PrepareAsyncGetMaxHitPointRaw(context, response, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> GetMinMaxHitPoints(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(GetMinMaxHitPointsRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> AsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(AsyncGetMinMaxHitPointsRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> PrepareAsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(PrepareAsyncGetMinMaxHitPointsRaw(context, cq)); + } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>* GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) = 0; + virtual ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>* AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>* PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* GetMinMaxHitPointsRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); + ::grpc::Status Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientWriter< flatbuffers::grpc::Message>> GetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return std::unique_ptr< ::grpc::ClientWriter< flatbuffers::grpc::Message>>(GetMaxHitPointRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>> AsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>>(AsyncGetMaxHitPointRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>> PrepareAsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>>(PrepareAsyncGetMaxHitPointRaw(context, response, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> GetMinMaxHitPoints(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(GetMinMaxHitPointsRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> AsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(AsyncGetMinMaxHitPointsRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> PrepareAsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(PrepareAsyncGetMinMaxHitPointsRaw(context, cq)); + } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) override; + ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientWriter< flatbuffers::grpc::Message>* GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) override; + ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* GetMinMaxHitPointsRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_Store_; + const ::grpc::internal::RpcMethod rpcmethod_Retrieve_; + const ::grpc::internal::RpcMethod rpcmethod_GetMaxHitPoint_; + const ::grpc::internal::RpcMethod rpcmethod_GetMinMaxHitPoints_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + virtual ::grpc::Status Store(::grpc::ServerContext* context, const flatbuffers::grpc::Message* request, flatbuffers::grpc::Message* response); + virtual ::grpc::Status Retrieve(::grpc::ServerContext* context, const flatbuffers::grpc::Message* request, ::grpc::ServerWriter< flatbuffers::grpc::Message>* writer); + virtual ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* context, ::grpc::ServerReader< flatbuffers::grpc::Message>* reader, flatbuffers::grpc::Message* response); + virtual ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* stream); + }; + template + class WithAsyncMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_Store() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStore(::grpc::ServerContext* context, flatbuffers::grpc::Message* request, ::grpc::ServerAsyncResponseWriter< flatbuffers::grpc::Message>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_Retrieve() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRetrieve(::grpc::ServerContext* context, flatbuffers::grpc::Message* request, ::grpc::ServerAsyncWriter< flatbuffers::grpc::Message>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetMaxHitPoint : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_GetMaxHitPoint() { + ::grpc::Service::MarkMethodAsync(2); + } + ~WithAsyncMethod_GetMaxHitPoint() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* response) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetMaxHitPoint(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(2, context, reader, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetMinMaxHitPoints : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_GetMinMaxHitPoints() { + ::grpc::Service::MarkMethodAsync(3); + } + ~WithAsyncMethod_GetMinMaxHitPoints() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetMinMaxHitPoints(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_Store< WithAsyncMethod_Retrieve< WithAsyncMethod_GetMaxHitPoint< WithAsyncMethod_GetMinMaxHitPoints< Service > > > > AsyncService; + template + class WithGenericMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_Store() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_Retrieve() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetMaxHitPoint : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_GetMaxHitPoint() { + ::grpc::Service::MarkMethodGeneric(2); + } + ~WithGenericMethod_GetMaxHitPoint() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetMinMaxHitPoints : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_GetMinMaxHitPoints() { + ::grpc::Service::MarkMethodGeneric(3); + } + ~WithGenericMethod_GetMinMaxHitPoints() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithStreamedUnaryMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithStreamedUnaryMethod_Store() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithStreamedUnaryMethod_Store::StreamedStore, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStore(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< flatbuffers::grpc::Message,flatbuffers::grpc::Message>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_Store< Service > StreamedUnaryService; + template + class WithSplitStreamingMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) { } + public: + WithSplitStreamingMethod_Retrieve() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::SplitServerStreamingHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithSplitStreamingMethod_Retrieve::StreamedRetrieve, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithSplitStreamingMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedRetrieve(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< flatbuffers::grpc::Message,flatbuffers::grpc::Message>* server_split_streamer) = 0; + }; + typedef WithSplitStreamingMethod_Retrieve< Service > SplitStreamedService; + typedef WithStreamedUnaryMethod_Store< WithSplitStreamingMethod_Retrieve< Service > > StreamedService; +}; + +} // namespace Example +} // namespace MyGame + + +#endif // GRPC_monster_5ftest__INCLUDED diff --git a/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h b/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h new file mode 100644 index 000000000..5e2308c7b --- /dev/null +++ b/tests/monster_test_suffix/filesuffix_only/monster_test_suffix.h @@ -0,0 +1,4041 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ +#define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ + +#include "flatbuffers/flatbuffers.h" +#include "flatbuffers/flexbuffers.h" +#include "flatbuffers/flex_flat_util.h" + +// Ensure the included flatbuffers.h is the same version as when this file was +// generated, otherwise it may not be compatible. +static_assert(FLATBUFFERS_VERSION_MAJOR == 2 && + FLATBUFFERS_VERSION_MINOR == 0 && + FLATBUFFERS_VERSION_REVISION == 6, + "Non-compatible flatbuffers version included"); + +namespace MyGame { + +struct InParentNamespace; +struct InParentNamespaceBuilder; +struct InParentNamespaceT; + +namespace Example2 { + +struct Monster; +struct MonsterBuilder; +struct MonsterT; + +} // namespace Example2 + +namespace Example { + +struct Test; + +struct TestSimpleTableWithEnum; +struct TestSimpleTableWithEnumBuilder; +struct TestSimpleTableWithEnumT; + +struct Vec3; + +struct Ability; + +struct StructOfStructs; + +struct StructOfStructsOfStructs; + +struct Stat; +struct StatBuilder; +struct StatT; + +struct Referrable; +struct ReferrableBuilder; +struct ReferrableT; + +struct Monster; +struct MonsterBuilder; +struct MonsterT; + +struct TypeAliases; +struct TypeAliasesBuilder; +struct TypeAliasesT; + +} // namespace Example + +bool operator==(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs); +bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs); +namespace Example2 { + +bool operator==(const MonsterT &lhs, const MonsterT &rhs); +bool operator!=(const MonsterT &lhs, const MonsterT &rhs); +} // namespace Example2 + +namespace Example { + +bool operator==(const Test &lhs, const Test &rhs); +bool operator!=(const Test &lhs, const Test &rhs); +bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs); +bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs); +bool operator==(const Vec3 &lhs, const Vec3 &rhs); +bool operator!=(const Vec3 &lhs, const Vec3 &rhs); +bool operator==(const Ability &lhs, const Ability &rhs); +bool operator!=(const Ability &lhs, const Ability &rhs); +bool operator==(const StructOfStructs &lhs, const StructOfStructs &rhs); +bool operator!=(const StructOfStructs &lhs, const StructOfStructs &rhs); +bool operator==(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs); +bool operator!=(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs); +bool operator==(const StatT &lhs, const StatT &rhs); +bool operator!=(const StatT &lhs, const StatT &rhs); +bool operator==(const ReferrableT &lhs, const ReferrableT &rhs); +bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs); +bool operator==(const MonsterT &lhs, const MonsterT &rhs); +bool operator!=(const MonsterT &lhs, const MonsterT &rhs); +bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs); +bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs); + +} // namespace Example + +inline const flatbuffers::TypeTable *InParentNamespaceTypeTable(); + +namespace Example2 { + +inline const flatbuffers::TypeTable *MonsterTypeTable(); + +} // namespace Example2 + +namespace Example { + +inline const flatbuffers::TypeTable *TestTypeTable(); + +inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable(); + +inline const flatbuffers::TypeTable *Vec3TypeTable(); + +inline const flatbuffers::TypeTable *AbilityTypeTable(); + +inline const flatbuffers::TypeTable *StructOfStructsTypeTable(); + +inline const flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable(); + +inline const flatbuffers::TypeTable *StatTypeTable(); + +inline const flatbuffers::TypeTable *ReferrableTypeTable(); + +inline const flatbuffers::TypeTable *MonsterTypeTable(); + +inline const flatbuffers::TypeTable *TypeAliasesTypeTable(); + +/// Composite components of Monster color. +enum Color : uint8_t { + Color_Red = 1, + /// \brief color Green + /// Green is bit_flag with value (1u << 1) + Color_Green = 2, + /// \brief color Blue (1u << 3) + Color_Blue = 8, + Color_NONE = 0, + Color_ANY = 11 +}; + +inline const Color (&EnumValuesColor())[3] { + static const Color values[] = { + Color_Red, + Color_Green, + Color_Blue + }; + return values; +} + +inline const char * const *EnumNamesColor() { + static const char * const names[9] = { + "Red", + "Green", + "", + "", + "", + "", + "", + "Blue", + nullptr + }; + return names; +} + +inline const char *EnumNameColor(Color e) { + if (flatbuffers::IsOutRange(e, Color_Red, Color_Blue)) return ""; + const size_t index = static_cast(e) - static_cast(Color_Red); + return EnumNamesColor()[index]; +} + +enum Race : int8_t { + Race_None = -1, + Race_Human = 0, + Race_Dwarf = 1, + Race_Elf = 2, + Race_MIN = Race_None, + Race_MAX = Race_Elf +}; + +inline const Race (&EnumValuesRace())[4] { + static const Race values[] = { + Race_None, + Race_Human, + Race_Dwarf, + Race_Elf + }; + return values; +} + +inline const char * const *EnumNamesRace() { + static const char * const names[5] = { + "None", + "Human", + "Dwarf", + "Elf", + nullptr + }; + return names; +} + +inline const char *EnumNameRace(Race e) { + if (flatbuffers::IsOutRange(e, Race_None, Race_Elf)) return ""; + const size_t index = static_cast(e) - static_cast(Race_None); + return EnumNamesRace()[index]; +} + +enum LongEnum : uint64_t { + LongEnum_LongOne = 2ULL, + LongEnum_LongTwo = 4ULL, + LongEnum_LongBig = 1099511627776ULL, + LongEnum_NONE = 0, + LongEnum_ANY = 1099511627782ULL +}; + +inline const LongEnum (&EnumValuesLongEnum())[3] { + static const LongEnum values[] = { + LongEnum_LongOne, + LongEnum_LongTwo, + LongEnum_LongBig + }; + return values; +} + +inline const char *EnumNameLongEnum(LongEnum e) { + switch (e) { + case LongEnum_LongOne: return "LongOne"; + case LongEnum_LongTwo: return "LongTwo"; + case LongEnum_LongBig: return "LongBig"; + default: return ""; + } +} + +enum Any : uint8_t { + Any_NONE = 0, + Any_Monster = 1, + Any_TestSimpleTableWithEnum = 2, + Any_MyGame_Example2_Monster = 3, + Any_MIN = Any_NONE, + Any_MAX = Any_MyGame_Example2_Monster +}; + +inline const Any (&EnumValuesAny())[4] { + static const Any values[] = { + Any_NONE, + Any_Monster, + Any_TestSimpleTableWithEnum, + Any_MyGame_Example2_Monster + }; + return values; +} + +inline const char * const *EnumNamesAny() { + static const char * const names[5] = { + "NONE", + "Monster", + "TestSimpleTableWithEnum", + "MyGame_Example2_Monster", + nullptr + }; + return names; +} + +inline const char *EnumNameAny(Any e) { + if (flatbuffers::IsOutRange(e, Any_NONE, Any_MyGame_Example2_Monster)) return ""; + const size_t index = static_cast(e); + return EnumNamesAny()[index]; +} + +template struct AnyTraits { + static const Any enum_value = Any_NONE; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_Monster; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_TestSimpleTableWithEnum; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_MyGame_Example2_Monster; +}; + +template struct AnyUnionTraits { + static const Any enum_value = Any_NONE; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_Monster; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_TestSimpleTableWithEnum; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_MyGame_Example2_Monster; +}; + +struct AnyUnion { + Any type; + void *value; + + AnyUnion() : type(Any_NONE), value(nullptr) {} + AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT : + type(Any_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyUnion(const AnyUnion &); + AnyUnion &operator=(const AnyUnion &u) + { AnyUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = AnyUnionTraits::enum_value; + if (type != Any_NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsMonster() { + return type == Any_Monster ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsMonster() const { + return type == Any_Monster ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() { + return type == Any_TestSimpleTableWithEnum ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() const { + return type == Any_TestSimpleTableWithEnum ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() { + return type == Any_MyGame_Example2_Monster ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() const { + return type == Any_MyGame_Example2_Monster ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyUnion &lhs, const AnyUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case Any_NONE: { + return true; + } + case Any_Monster: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case Any_TestSimpleTableWithEnum: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case Any_MyGame_Example2_Monster: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type); +bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum AnyUniqueAliases : uint8_t { + AnyUniqueAliases_NONE = 0, + AnyUniqueAliases_M = 1, + AnyUniqueAliases_TS = 2, + AnyUniqueAliases_M2 = 3, + AnyUniqueAliases_MIN = AnyUniqueAliases_NONE, + AnyUniqueAliases_MAX = AnyUniqueAliases_M2 +}; + +inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] { + static const AnyUniqueAliases values[] = { + AnyUniqueAliases_NONE, + AnyUniqueAliases_M, + AnyUniqueAliases_TS, + AnyUniqueAliases_M2 + }; + return values; +} + +inline const char * const *EnumNamesAnyUniqueAliases() { + static const char * const names[5] = { + "NONE", + "M", + "TS", + "M2", + nullptr + }; + return names; +} + +inline const char *EnumNameAnyUniqueAliases(AnyUniqueAliases e) { + if (flatbuffers::IsOutRange(e, AnyUniqueAliases_NONE, AnyUniqueAliases_M2)) return ""; + const size_t index = static_cast(e); + return EnumNamesAnyUniqueAliases()[index]; +} + +template struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2; +}; + +template struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2; +}; + +struct AnyUniqueAliasesUnion { + AnyUniqueAliases type; + void *value; + + AnyUniqueAliasesUnion() : type(AnyUniqueAliases_NONE), value(nullptr) {} + AnyUniqueAliasesUnion(AnyUniqueAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(AnyUniqueAliases_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &); + AnyUniqueAliasesUnion &operator=(const AnyUniqueAliasesUnion &u) + { AnyUniqueAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyUniqueAliasesUnion &operator=(AnyUniqueAliasesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyUniqueAliasesUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = AnyUniqueAliasesUnionTraits::enum_value; + if (type != AnyUniqueAliases_NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsM() { + return type == AnyUniqueAliases_M ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM() const { + return type == AnyUniqueAliases_M ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::TestSimpleTableWithEnumT *AsTS() { + return type == AnyUniqueAliases_TS ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnumT *AsTS() const { + return type == AnyUniqueAliases_TS ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example2::MonsterT *AsM2() { + return type == AnyUniqueAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example2::MonsterT *AsM2() const { + return type == AnyUniqueAliases_M2 ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case AnyUniqueAliases_NONE: { + return true; + } + case AnyUniqueAliases_M: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyUniqueAliases_TS: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyUniqueAliases_M2: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type); +bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum AnyAmbiguousAliases : uint8_t { + AnyAmbiguousAliases_NONE = 0, + AnyAmbiguousAliases_M1 = 1, + AnyAmbiguousAliases_M2 = 2, + AnyAmbiguousAliases_M3 = 3, + AnyAmbiguousAliases_MIN = AnyAmbiguousAliases_NONE, + AnyAmbiguousAliases_MAX = AnyAmbiguousAliases_M3 +}; + +inline const AnyAmbiguousAliases (&EnumValuesAnyAmbiguousAliases())[4] { + static const AnyAmbiguousAliases values[] = { + AnyAmbiguousAliases_NONE, + AnyAmbiguousAliases_M1, + AnyAmbiguousAliases_M2, + AnyAmbiguousAliases_M3 + }; + return values; +} + +inline const char * const *EnumNamesAnyAmbiguousAliases() { + static const char * const names[5] = { + "NONE", + "M1", + "M2", + "M3", + nullptr + }; + return names; +} + +inline const char *EnumNameAnyAmbiguousAliases(AnyAmbiguousAliases e) { + if (flatbuffers::IsOutRange(e, AnyAmbiguousAliases_NONE, AnyAmbiguousAliases_M3)) return ""; + const size_t index = static_cast(e); + return EnumNamesAnyAmbiguousAliases()[index]; +} + +struct AnyAmbiguousAliasesUnion { + AnyAmbiguousAliases type; + void *value; + + AnyAmbiguousAliasesUnion() : type(AnyAmbiguousAliases_NONE), value(nullptr) {} + AnyAmbiguousAliasesUnion(AnyAmbiguousAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(AnyAmbiguousAliases_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &); + AnyAmbiguousAliasesUnion &operator=(const AnyAmbiguousAliasesUnion &u) + { AnyAmbiguousAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyAmbiguousAliasesUnion &operator=(AnyAmbiguousAliasesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyAmbiguousAliasesUnion() { Reset(); } + + void Reset(); + + static void *UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsM1() { + return type == AnyAmbiguousAliases_M1 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM1() const { + return type == AnyAmbiguousAliases_M1 ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::MonsterT *AsM2() { + return type == AnyAmbiguousAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM2() const { + return type == AnyAmbiguousAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::MonsterT *AsM3() { + return type == AnyAmbiguousAliases_M3 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM3() const { + return type == AnyAmbiguousAliases_M3 ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case AnyAmbiguousAliases_NONE: { + return true; + } + case AnyAmbiguousAliases_M1: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyAmbiguousAliases_M2: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyAmbiguousAliases_M3: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type); +bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS { + private: + int16_t a_; + int8_t b_; + int8_t padding0__; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TestTypeTable(); + } + Test() + : a_(0), + b_(0), + padding0__(0) { + (void)padding0__; + } + Test(int16_t _a, int8_t _b) + : a_(flatbuffers::EndianScalar(_a)), + b_(flatbuffers::EndianScalar(_b)), + padding0__(0) { + (void)padding0__; + } + int16_t a() const { + return flatbuffers::EndianScalar(a_); + } + void mutate_a(int16_t _a) { + flatbuffers::WriteScalar(&a_, _a); + } + int8_t b() const { + return flatbuffers::EndianScalar(b_); + } + void mutate_b(int8_t _b) { + flatbuffers::WriteScalar(&b_, _b); + } +}; +FLATBUFFERS_STRUCT_END(Test, 4); + +inline bool operator==(const Test &lhs, const Test &rhs) { + return + (lhs.a() == rhs.a()) && + (lhs.b() == rhs.b()); +} + +inline bool operator!=(const Test &lhs, const Test &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Vec3 FLATBUFFERS_FINAL_CLASS { + private: + float x_; + float y_; + float z_; + int32_t padding0__; + double test1_; + uint8_t test2_; + int8_t padding1__; + MyGame::Example::Test test3_; + int16_t padding2__; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return Vec3TypeTable(); + } + Vec3() + : x_(0), + y_(0), + z_(0), + padding0__(0), + test1_(0), + test2_(0), + padding1__(0), + test3_(), + padding2__(0) { + (void)padding0__; + (void)padding1__; + (void)padding2__; + } + Vec3(float _x, float _y, float _z, double _test1, MyGame::Example::Color _test2, const MyGame::Example::Test &_test3) + : x_(flatbuffers::EndianScalar(_x)), + y_(flatbuffers::EndianScalar(_y)), + z_(flatbuffers::EndianScalar(_z)), + padding0__(0), + test1_(flatbuffers::EndianScalar(_test1)), + test2_(flatbuffers::EndianScalar(static_cast(_test2))), + padding1__(0), + test3_(_test3), + padding2__(0) { + (void)padding0__; + (void)padding1__; + (void)padding2__; + } + float x() const { + return flatbuffers::EndianScalar(x_); + } + void mutate_x(float _x) { + flatbuffers::WriteScalar(&x_, _x); + } + float y() const { + return flatbuffers::EndianScalar(y_); + } + void mutate_y(float _y) { + flatbuffers::WriteScalar(&y_, _y); + } + float z() const { + return flatbuffers::EndianScalar(z_); + } + void mutate_z(float _z) { + flatbuffers::WriteScalar(&z_, _z); + } + double test1() const { + return flatbuffers::EndianScalar(test1_); + } + void mutate_test1(double _test1) { + flatbuffers::WriteScalar(&test1_, _test1); + } + MyGame::Example::Color test2() const { + return static_cast(flatbuffers::EndianScalar(test2_)); + } + void mutate_test2(MyGame::Example::Color _test2) { + flatbuffers::WriteScalar(&test2_, static_cast(_test2)); + } + const MyGame::Example::Test &test3() const { + return test3_; + } + MyGame::Example::Test &mutable_test3() { + return test3_; + } +}; +FLATBUFFERS_STRUCT_END(Vec3, 32); + +inline bool operator==(const Vec3 &lhs, const Vec3 &rhs) { + return + (lhs.x() == rhs.x()) && + (lhs.y() == rhs.y()) && + (lhs.z() == rhs.z()) && + (lhs.test1() == rhs.test1()) && + (lhs.test2() == rhs.test2()) && + (lhs.test3() == rhs.test3()); +} + +inline bool operator!=(const Vec3 &lhs, const Vec3 &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ability FLATBUFFERS_FINAL_CLASS { + private: + uint32_t id_; + uint32_t distance_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return AbilityTypeTable(); + } + Ability() + : id_(0), + distance_(0) { + } + Ability(uint32_t _id, uint32_t _distance) + : id_(flatbuffers::EndianScalar(_id)), + distance_(flatbuffers::EndianScalar(_distance)) { + } + uint32_t id() const { + return flatbuffers::EndianScalar(id_); + } + void mutate_id(uint32_t _id) { + flatbuffers::WriteScalar(&id_, _id); + } + bool KeyCompareLessThan(const Ability *o) const { + return id() < o->id(); + } + int KeyCompareWithValue(uint32_t _id) const { + return static_cast(id() > _id) - static_cast(id() < _id); + } + uint32_t distance() const { + return flatbuffers::EndianScalar(distance_); + } + void mutate_distance(uint32_t _distance) { + flatbuffers::WriteScalar(&distance_, _distance); + } +}; +FLATBUFFERS_STRUCT_END(Ability, 8); + +inline bool operator==(const Ability &lhs, const Ability &rhs) { + return + (lhs.id() == rhs.id()) && + (lhs.distance() == rhs.distance()); +} + +inline bool operator!=(const Ability &lhs, const Ability &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructs FLATBUFFERS_FINAL_CLASS { + private: + MyGame::Example::Ability a_; + MyGame::Example::Test b_; + MyGame::Example::Ability c_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StructOfStructsTypeTable(); + } + StructOfStructs() + : a_(), + b_(), + c_() { + } + StructOfStructs(const MyGame::Example::Ability &_a, const MyGame::Example::Test &_b, const MyGame::Example::Ability &_c) + : a_(_a), + b_(_b), + c_(_c) { + } + const MyGame::Example::Ability &a() const { + return a_; + } + MyGame::Example::Ability &mutable_a() { + return a_; + } + const MyGame::Example::Test &b() const { + return b_; + } + MyGame::Example::Test &mutable_b() { + return b_; + } + const MyGame::Example::Ability &c() const { + return c_; + } + MyGame::Example::Ability &mutable_c() { + return c_; + } +}; +FLATBUFFERS_STRUCT_END(StructOfStructs, 20); + +inline bool operator==(const StructOfStructs &lhs, const StructOfStructs &rhs) { + return + (lhs.a() == rhs.a()) && + (lhs.b() == rhs.b()) && + (lhs.c() == rhs.c()); +} + +inline bool operator!=(const StructOfStructs &lhs, const StructOfStructs &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructsOfStructs FLATBUFFERS_FINAL_CLASS { + private: + MyGame::Example::StructOfStructs a_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StructOfStructsOfStructsTypeTable(); + } + StructOfStructsOfStructs() + : a_() { + } + StructOfStructsOfStructs(const MyGame::Example::StructOfStructs &_a) + : a_(_a) { + } + const MyGame::Example::StructOfStructs &a() const { + return a_; + } + MyGame::Example::StructOfStructs &mutable_a() { + return a_; + } +}; +FLATBUFFERS_STRUCT_END(StructOfStructsOfStructs, 20); + +inline bool operator==(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs) { + return + (lhs.a() == rhs.a()); +} + +inline bool operator!=(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs) { + return !(lhs == rhs); +} + + +} // namespace Example + +struct InParentNamespaceT : public flatbuffers::NativeTable { + typedef InParentNamespace TableType; +}; + +struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InParentNamespaceT NativeTableType; + typedef InParentNamespaceBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return InParentNamespaceTypeTable(); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } + InParentNamespaceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct InParentNamespaceBuilder { + typedef InParentNamespace Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit InParentNamespaceBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInParentNamespace( + flatbuffers::FlatBufferBuilder &_fbb) { + InParentNamespaceBuilder builder_(_fbb); + return builder_.Finish(); +} + +flatbuffers::Offset CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +namespace Example2 { + +struct MonsterT : public flatbuffers::NativeTable { + typedef Monster TableType; +}; + +struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MonsterT NativeTableType; + typedef MonsterBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return MonsterTypeTable(); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } + MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct MonsterBuilder { + typedef Monster Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb) { + MonsterBuilder builder_(_fbb); + return builder_.Finish(); +} + +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +} // namespace Example2 + +namespace Example { + +struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable { + typedef TestSimpleTableWithEnum TableType; + MyGame::Example::Color color = MyGame::Example::Color_Green; +}; + +struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TestSimpleTableWithEnumT NativeTableType; + typedef TestSimpleTableWithEnumBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TestSimpleTableWithEnumTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_COLOR = 4 + }; + MyGame::Example::Color color() const { + return static_cast(GetField(VT_COLOR, 2)); + } + bool mutate_color(MyGame::Example::Color _color = static_cast(2)) { + return SetField(VT_COLOR, static_cast(_color), 2); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_COLOR, 1) && + verifier.EndTable(); + } + TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TestSimpleTableWithEnumBuilder { + typedef TestSimpleTableWithEnum Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_color(MyGame::Example::Color color) { + fbb_.AddElement(TestSimpleTableWithEnum::VT_COLOR, static_cast(color), 2); + } + explicit TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTestSimpleTableWithEnum( + flatbuffers::FlatBufferBuilder &_fbb, + MyGame::Example::Color color = MyGame::Example::Color_Green) { + TestSimpleTableWithEnumBuilder builder_(_fbb); + builder_.add_color(color); + return builder_.Finish(); +} + +flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct StatT : public flatbuffers::NativeTable { + typedef Stat TableType; + std::string id{}; + int64_t val = 0; + uint16_t count = 0; +}; + +struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StatT NativeTableType; + typedef StatBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StatTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4, + VT_VAL = 6, + VT_COUNT = 8 + }; + const flatbuffers::String *id() const { + return GetPointer(VT_ID); + } + flatbuffers::String *mutable_id() { + return GetPointer(VT_ID); + } + int64_t val() const { + return GetField(VT_VAL, 0); + } + bool mutate_val(int64_t _val = 0) { + return SetField(VT_VAL, _val, 0); + } + uint16_t count() const { + return GetField(VT_COUNT, 0); + } + bool mutate_count(uint16_t _count = 0) { + return SetField(VT_COUNT, _count, 0); + } + bool KeyCompareLessThan(const Stat *o) const { + return count() < o->count(); + } + int KeyCompareWithValue(uint16_t _count) const { + return static_cast(count() > _count) - static_cast(count() < _count); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ID) && + verifier.VerifyString(id()) && + VerifyField(verifier, VT_VAL, 8) && + VerifyField(verifier, VT_COUNT, 2) && + verifier.EndTable(); + } + StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct StatBuilder { + typedef Stat Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(flatbuffers::Offset id) { + fbb_.AddOffset(Stat::VT_ID, id); + } + void add_val(int64_t val) { + fbb_.AddElement(Stat::VT_VAL, val, 0); + } + void add_count(uint16_t count) { + fbb_.AddElement(Stat::VT_COUNT, count, 0); + } + explicit StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStat( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset id = 0, + int64_t val = 0, + uint16_t count = 0) { + StatBuilder builder_(_fbb); + builder_.add_val(val); + builder_.add_id(id); + builder_.add_count(count); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStatDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *id = nullptr, + int64_t val = 0, + uint16_t count = 0) { + auto id__ = id ? _fbb.CreateString(id) : 0; + return MyGame::Example::CreateStat( + _fbb, + id__, + val, + count); +} + +flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReferrableT : public flatbuffers::NativeTable { + typedef Referrable TableType; + uint64_t id = 0; +}; + +struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReferrableT NativeTableType; + typedef ReferrableBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return ReferrableTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4 + }; + uint64_t id() const { + return GetField(VT_ID, 0); + } + bool mutate_id(uint64_t _id = 0) { + return SetField(VT_ID, _id, 0); + } + bool KeyCompareLessThan(const Referrable *o) const { + return id() < o->id(); + } + int KeyCompareWithValue(uint64_t _id) const { + return static_cast(id() > _id) - static_cast(id() < _id); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ID, 8) && + verifier.EndTable(); + } + ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReferrableBuilder { + typedef Referrable Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(uint64_t id) { + fbb_.AddElement(Referrable::VT_ID, id, 0); + } + explicit ReferrableBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateReferrable( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t id = 0) { + ReferrableBuilder builder_(_fbb); + builder_.add_id(id); + return builder_.Finish(); +} + +flatbuffers::Offset CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct MonsterT : public flatbuffers::NativeTable { + typedef Monster TableType; + flatbuffers::unique_ptr pos{}; + int16_t mana = 150; + int16_t hp = 100; + std::string name{}; + std::vector inventory{}; + MyGame::Example::Color color = MyGame::Example::Color_Blue; + MyGame::Example::AnyUnion test{}; + std::vector test4{}; + std::vector testarrayofstring{}; + std::vector> testarrayoftables{}; + flatbuffers::unique_ptr enemy{}; + std::vector testnestedflatbuffer{}; + flatbuffers::unique_ptr testempty{}; + bool testbool = false; + int32_t testhashs32_fnv1 = 0; + uint32_t testhashu32_fnv1 = 0; + int64_t testhashs64_fnv1 = 0; + uint64_t testhashu64_fnv1 = 0; + int32_t testhashs32_fnv1a = 0; + Stat *testhashu32_fnv1a = nullptr; + int64_t testhashs64_fnv1a = 0; + uint64_t testhashu64_fnv1a = 0; + std::vector testarrayofbools{}; + float testf = 3.14159f; + float testf2 = 3.0f; + float testf3 = 0.0f; + std::vector testarrayofstring2{}; + std::vector testarrayofsortedstruct{}; + std::vector flex{}; + std::vector test5{}; + std::vector vector_of_longs{}; + std::vector vector_of_doubles{}; + flatbuffers::unique_ptr parent_namespace_test{}; + std::vector> vector_of_referrables{}; + ReferrableT *single_weak_reference = nullptr; + std::vector vector_of_weak_references{}; + std::vector> vector_of_strong_referrables{}; + ReferrableT *co_owning_reference = nullptr; + std::vector> vector_of_co_owning_references{}; + ReferrableT *non_owning_reference = nullptr; + std::vector vector_of_non_owning_references{}; + MyGame::Example::AnyUniqueAliasesUnion any_unique{}; + MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous{}; + std::vector vector_of_enums{}; + MyGame::Example::Race signed_enum = MyGame::Example::Race_None; + std::vector testrequirednestedflatbuffer{}; + std::vector> scalar_key_sorted_tables{}; + MyGame::Example::Test native_inline{}; + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0); + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne; + MonsterT() = default; + MonsterT(const MonsterT &o); + MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default; + MonsterT &operator=(MonsterT o) FLATBUFFERS_NOEXCEPT; +}; + +/// an example documentation comment: "monster object" +struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MonsterT NativeTableType; + typedef MonsterBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return MonsterTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POS = 4, + VT_MANA = 6, + VT_HP = 8, + VT_NAME = 10, + VT_INVENTORY = 14, + VT_COLOR = 16, + VT_TEST_TYPE = 18, + VT_TEST = 20, + VT_TEST4 = 22, + VT_TESTARRAYOFSTRING = 24, + VT_TESTARRAYOFTABLES = 26, + VT_ENEMY = 28, + VT_TESTNESTEDFLATBUFFER = 30, + VT_TESTEMPTY = 32, + VT_TESTBOOL = 34, + VT_TESTHASHS32_FNV1 = 36, + VT_TESTHASHU32_FNV1 = 38, + VT_TESTHASHS64_FNV1 = 40, + VT_TESTHASHU64_FNV1 = 42, + VT_TESTHASHS32_FNV1A = 44, + VT_TESTHASHU32_FNV1A = 46, + VT_TESTHASHS64_FNV1A = 48, + VT_TESTHASHU64_FNV1A = 50, + VT_TESTARRAYOFBOOLS = 52, + VT_TESTF = 54, + VT_TESTF2 = 56, + VT_TESTF3 = 58, + VT_TESTARRAYOFSTRING2 = 60, + VT_TESTARRAYOFSORTEDSTRUCT = 62, + VT_FLEX = 64, + VT_TEST5 = 66, + VT_VECTOR_OF_LONGS = 68, + VT_VECTOR_OF_DOUBLES = 70, + VT_PARENT_NAMESPACE_TEST = 72, + VT_VECTOR_OF_REFERRABLES = 74, + VT_SINGLE_WEAK_REFERENCE = 76, + VT_VECTOR_OF_WEAK_REFERENCES = 78, + VT_VECTOR_OF_STRONG_REFERRABLES = 80, + VT_CO_OWNING_REFERENCE = 82, + VT_VECTOR_OF_CO_OWNING_REFERENCES = 84, + VT_NON_OWNING_REFERENCE = 86, + VT_VECTOR_OF_NON_OWNING_REFERENCES = 88, + VT_ANY_UNIQUE_TYPE = 90, + VT_ANY_UNIQUE = 92, + VT_ANY_AMBIGUOUS_TYPE = 94, + VT_ANY_AMBIGUOUS = 96, + VT_VECTOR_OF_ENUMS = 98, + VT_SIGNED_ENUM = 100, + VT_TESTREQUIREDNESTEDFLATBUFFER = 102, + VT_SCALAR_KEY_SORTED_TABLES = 104, + VT_NATIVE_INLINE = 106, + VT_LONG_ENUM_NON_ENUM_DEFAULT = 108, + VT_LONG_ENUM_NORMAL_DEFAULT = 110 + }; + const MyGame::Example::Vec3 *pos() const { + return GetStruct(VT_POS); + } + MyGame::Example::Vec3 *mutable_pos() { + return GetStruct(VT_POS); + } + int16_t mana() const { + return GetField(VT_MANA, 150); + } + bool mutate_mana(int16_t _mana = 150) { + return SetField(VT_MANA, _mana, 150); + } + int16_t hp() const { + return GetField(VT_HP, 100); + } + bool mutate_hp(int16_t _hp = 100) { + return SetField(VT_HP, _hp, 100); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + flatbuffers::String *mutable_name() { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Monster *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *_name) const { + return strcmp(name()->c_str(), _name); + } + const flatbuffers::Vector *inventory() const { + return GetPointer *>(VT_INVENTORY); + } + flatbuffers::Vector *mutable_inventory() { + return GetPointer *>(VT_INVENTORY); + } + MyGame::Example::Color color() const { + return static_cast(GetField(VT_COLOR, 8)); + } + bool mutate_color(MyGame::Example::Color _color = static_cast(8)) { + return SetField(VT_COLOR, static_cast(_color), 8); + } + MyGame::Example::Any test_type() const { + return static_cast(GetField(VT_TEST_TYPE, 0)); + } + const void *test() const { + return GetPointer(VT_TEST); + } + template const T *test_as() const; + const MyGame::Example::Monster *test_as_Monster() const { + return test_type() == MyGame::Example::Any_Monster ? static_cast(test()) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const { + return test_type() == MyGame::Example::Any_TestSimpleTableWithEnum ? static_cast(test()) : nullptr; + } + const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const { + return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast(test()) : nullptr; + } + void *mutable_test() { + return GetPointer(VT_TEST); + } + const flatbuffers::Vector *test4() const { + return GetPointer *>(VT_TEST4); + } + flatbuffers::Vector *mutable_test4() { + return GetPointer *>(VT_TEST4); + } + const flatbuffers::Vector> *testarrayofstring() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } + flatbuffers::Vector> *mutable_testarrayofstring() { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } + /// an example documentation comment: this will end up in the generated code + /// multiline too + const flatbuffers::Vector> *testarrayoftables() const { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + flatbuffers::Vector> *mutable_testarrayoftables() { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + const MyGame::Example::Monster *enemy() const { + return GetPointer(VT_ENEMY); + } + MyGame::Example::Monster *mutable_enemy() { + return GetPointer(VT_ENEMY); + } + const flatbuffers::Vector *testnestedflatbuffer() const { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + flatbuffers::Vector *mutable_testnestedflatbuffer() { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const { + return flatbuffers::GetRoot(testnestedflatbuffer()->Data()); + } + const MyGame::Example::Stat *testempty() const { + return GetPointer(VT_TESTEMPTY); + } + MyGame::Example::Stat *mutable_testempty() { + return GetPointer(VT_TESTEMPTY); + } + bool testbool() const { + return GetField(VT_TESTBOOL, 0) != 0; + } + bool mutate_testbool(bool _testbool = 0) { + return SetField(VT_TESTBOOL, static_cast(_testbool), 0); + } + int32_t testhashs32_fnv1() const { + return GetField(VT_TESTHASHS32_FNV1, 0); + } + bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1 = 0) { + return SetField(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0); + } + uint32_t testhashu32_fnv1() const { + return GetField(VT_TESTHASHU32_FNV1, 0); + } + bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1 = 0) { + return SetField(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0); + } + int64_t testhashs64_fnv1() const { + return GetField(VT_TESTHASHS64_FNV1, 0); + } + bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1 = 0) { + return SetField(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0); + } + uint64_t testhashu64_fnv1() const { + return GetField(VT_TESTHASHU64_FNV1, 0); + } + bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1 = 0) { + return SetField(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0); + } + int32_t testhashs32_fnv1a() const { + return GetField(VT_TESTHASHS32_FNV1A, 0); + } + bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a = 0) { + return SetField(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0); + } + uint32_t testhashu32_fnv1a() const { + return GetField(VT_TESTHASHU32_FNV1A, 0); + } + bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a = 0) { + return SetField(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0); + } + int64_t testhashs64_fnv1a() const { + return GetField(VT_TESTHASHS64_FNV1A, 0); + } + bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a = 0) { + return SetField(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0); + } + uint64_t testhashu64_fnv1a() const { + return GetField(VT_TESTHASHU64_FNV1A, 0); + } + bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a = 0) { + return SetField(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0); + } + const flatbuffers::Vector *testarrayofbools() const { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + flatbuffers::Vector *mutable_testarrayofbools() { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + float testf() const { + return GetField(VT_TESTF, 3.14159f); + } + bool mutate_testf(float _testf = 3.14159f) { + return SetField(VT_TESTF, _testf, 3.14159f); + } + float testf2() const { + return GetField(VT_TESTF2, 3.0f); + } + bool mutate_testf2(float _testf2 = 3.0f) { + return SetField(VT_TESTF2, _testf2, 3.0f); + } + float testf3() const { + return GetField(VT_TESTF3, 0.0f); + } + bool mutate_testf3(float _testf3 = 0.0f) { + return SetField(VT_TESTF3, _testf3, 0.0f); + } + const flatbuffers::Vector> *testarrayofstring2() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } + flatbuffers::Vector> *mutable_testarrayofstring2() { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } + const flatbuffers::Vector *testarrayofsortedstruct() const { + return GetPointer *>(VT_TESTARRAYOFSORTEDSTRUCT); + } + flatbuffers::Vector *mutable_testarrayofsortedstruct() { + return GetPointer *>(VT_TESTARRAYOFSORTEDSTRUCT); + } + const flatbuffers::Vector *flex() const { + return GetPointer *>(VT_FLEX); + } + flatbuffers::Vector *mutable_flex() { + return GetPointer *>(VT_FLEX); + } + flexbuffers::Reference flex_flexbuffer_root() const { + return flexbuffers::GetRoot(flex()->Data(), flex()->size()); + } + const flatbuffers::Vector *test5() const { + return GetPointer *>(VT_TEST5); + } + flatbuffers::Vector *mutable_test5() { + return GetPointer *>(VT_TEST5); + } + const flatbuffers::Vector *vector_of_longs() const { + return GetPointer *>(VT_VECTOR_OF_LONGS); + } + flatbuffers::Vector *mutable_vector_of_longs() { + return GetPointer *>(VT_VECTOR_OF_LONGS); + } + const flatbuffers::Vector *vector_of_doubles() const { + return GetPointer *>(VT_VECTOR_OF_DOUBLES); + } + flatbuffers::Vector *mutable_vector_of_doubles() { + return GetPointer *>(VT_VECTOR_OF_DOUBLES); + } + const MyGame::InParentNamespace *parent_namespace_test() const { + return GetPointer(VT_PARENT_NAMESPACE_TEST); + } + MyGame::InParentNamespace *mutable_parent_namespace_test() { + return GetPointer(VT_PARENT_NAMESPACE_TEST); + } + const flatbuffers::Vector> *vector_of_referrables() const { + return GetPointer> *>(VT_VECTOR_OF_REFERRABLES); + } + flatbuffers::Vector> *mutable_vector_of_referrables() { + return GetPointer> *>(VT_VECTOR_OF_REFERRABLES); + } + uint64_t single_weak_reference() const { + return GetField(VT_SINGLE_WEAK_REFERENCE, 0); + } + bool mutate_single_weak_reference(uint64_t _single_weak_reference = 0) { + return SetField(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0); + } + const flatbuffers::Vector *vector_of_weak_references() const { + return GetPointer *>(VT_VECTOR_OF_WEAK_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_weak_references() { + return GetPointer *>(VT_VECTOR_OF_WEAK_REFERENCES); + } + const flatbuffers::Vector> *vector_of_strong_referrables() const { + return GetPointer> *>(VT_VECTOR_OF_STRONG_REFERRABLES); + } + flatbuffers::Vector> *mutable_vector_of_strong_referrables() { + return GetPointer> *>(VT_VECTOR_OF_STRONG_REFERRABLES); + } + uint64_t co_owning_reference() const { + return GetField(VT_CO_OWNING_REFERENCE, 0); + } + bool mutate_co_owning_reference(uint64_t _co_owning_reference = 0) { + return SetField(VT_CO_OWNING_REFERENCE, _co_owning_reference, 0); + } + const flatbuffers::Vector *vector_of_co_owning_references() const { + return GetPointer *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_co_owning_references() { + return GetPointer *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); + } + uint64_t non_owning_reference() const { + return GetField(VT_NON_OWNING_REFERENCE, 0); + } + bool mutate_non_owning_reference(uint64_t _non_owning_reference = 0) { + return SetField(VT_NON_OWNING_REFERENCE, _non_owning_reference, 0); + } + const flatbuffers::Vector *vector_of_non_owning_references() const { + return GetPointer *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_non_owning_references() { + return GetPointer *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); + } + MyGame::Example::AnyUniqueAliases any_unique_type() const { + return static_cast(GetField(VT_ANY_UNIQUE_TYPE, 0)); + } + const void *any_unique() const { + return GetPointer(VT_ANY_UNIQUE); + } + template const T *any_unique_as() const; + const MyGame::Example::Monster *any_unique_as_M() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_M ? static_cast(any_unique()) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnum *any_unique_as_TS() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_TS ? static_cast(any_unique()) : nullptr; + } + const MyGame::Example2::Monster *any_unique_as_M2() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast(any_unique()) : nullptr; + } + void *mutable_any_unique() { + return GetPointer(VT_ANY_UNIQUE); + } + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type() const { + return static_cast(GetField(VT_ANY_AMBIGUOUS_TYPE, 0)); + } + const void *any_ambiguous() const { + return GetPointer(VT_ANY_AMBIGUOUS); + } + const MyGame::Example::Monster *any_ambiguous_as_M1() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M1 ? static_cast(any_ambiguous()) : nullptr; + } + const MyGame::Example::Monster *any_ambiguous_as_M2() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M2 ? static_cast(any_ambiguous()) : nullptr; + } + const MyGame::Example::Monster *any_ambiguous_as_M3() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast(any_ambiguous()) : nullptr; + } + void *mutable_any_ambiguous() { + return GetPointer(VT_ANY_AMBIGUOUS); + } + const flatbuffers::Vector *vector_of_enums() const { + return GetPointer *>(VT_VECTOR_OF_ENUMS); + } + flatbuffers::Vector *mutable_vector_of_enums() { + return GetPointer *>(VT_VECTOR_OF_ENUMS); + } + MyGame::Example::Race signed_enum() const { + return static_cast(GetField(VT_SIGNED_ENUM, -1)); + } + bool mutate_signed_enum(MyGame::Example::Race _signed_enum = static_cast(-1)) { + return SetField(VT_SIGNED_ENUM, static_cast(_signed_enum), -1); + } + const flatbuffers::Vector *testrequirednestedflatbuffer() const { + return GetPointer *>(VT_TESTREQUIREDNESTEDFLATBUFFER); + } + flatbuffers::Vector *mutable_testrequirednestedflatbuffer() { + return GetPointer *>(VT_TESTREQUIREDNESTEDFLATBUFFER); + } + const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const { + return flatbuffers::GetRoot(testrequirednestedflatbuffer()->Data()); + } + const flatbuffers::Vector> *scalar_key_sorted_tables() const { + return GetPointer> *>(VT_SCALAR_KEY_SORTED_TABLES); + } + flatbuffers::Vector> *mutable_scalar_key_sorted_tables() { + return GetPointer> *>(VT_SCALAR_KEY_SORTED_TABLES); + } + const MyGame::Example::Test *native_inline() const { + return GetStruct(VT_NATIVE_INLINE); + } + MyGame::Example::Test *mutable_native_inline() { + return GetStruct(VT_NATIVE_INLINE); + } + MyGame::Example::LongEnum long_enum_non_enum_default() const { + return static_cast(GetField(VT_LONG_ENUM_NON_ENUM_DEFAULT, 0)); + } + bool mutate_long_enum_non_enum_default(MyGame::Example::LongEnum _long_enum_non_enum_default = static_cast(0)) { + return SetField(VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast(_long_enum_non_enum_default), 0); + } + MyGame::Example::LongEnum long_enum_normal_default() const { + return static_cast(GetField(VT_LONG_ENUM_NORMAL_DEFAULT, 2ULL)); + } + bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast(2ULL)) { + return SetField(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast(_long_enum_normal_default), 2ULL); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POS, 8) && + VerifyField(verifier, VT_MANA, 2) && + VerifyField(verifier, VT_HP, 2) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_INVENTORY) && + verifier.VerifyVector(inventory()) && + VerifyField(verifier, VT_COLOR, 1) && + VerifyField(verifier, VT_TEST_TYPE, 1) && + VerifyOffset(verifier, VT_TEST) && + VerifyAny(verifier, test(), test_type()) && + VerifyOffset(verifier, VT_TEST4) && + verifier.VerifyVector(test4()) && + VerifyOffset(verifier, VT_TESTARRAYOFSTRING) && + verifier.VerifyVector(testarrayofstring()) && + verifier.VerifyVectorOfStrings(testarrayofstring()) && + VerifyOffset(verifier, VT_TESTARRAYOFTABLES) && + verifier.VerifyVector(testarrayoftables()) && + verifier.VerifyVectorOfTables(testarrayoftables()) && + VerifyOffset(verifier, VT_ENEMY) && + verifier.VerifyTable(enemy()) && + VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) && + verifier.VerifyVector(testnestedflatbuffer()) && + verifier.VerifyNestedFlatBuffer(testnestedflatbuffer(), nullptr) && + VerifyOffset(verifier, VT_TESTEMPTY) && + verifier.VerifyTable(testempty()) && + VerifyField(verifier, VT_TESTBOOL, 1) && + VerifyField(verifier, VT_TESTHASHS32_FNV1, 4) && + VerifyField(verifier, VT_TESTHASHU32_FNV1, 4) && + VerifyField(verifier, VT_TESTHASHS64_FNV1, 8) && + VerifyField(verifier, VT_TESTHASHU64_FNV1, 8) && + VerifyField(verifier, VT_TESTHASHS32_FNV1A, 4) && + VerifyField(verifier, VT_TESTHASHU32_FNV1A, 4) && + VerifyField(verifier, VT_TESTHASHS64_FNV1A, 8) && + VerifyField(verifier, VT_TESTHASHU64_FNV1A, 8) && + VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) && + verifier.VerifyVector(testarrayofbools()) && + VerifyField(verifier, VT_TESTF, 4) && + VerifyField(verifier, VT_TESTF2, 4) && + VerifyField(verifier, VT_TESTF3, 4) && + VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) && + verifier.VerifyVector(testarrayofstring2()) && + verifier.VerifyVectorOfStrings(testarrayofstring2()) && + VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) && + verifier.VerifyVector(testarrayofsortedstruct()) && + VerifyOffset(verifier, VT_FLEX) && + verifier.VerifyVector(flex()) && + flexbuffers::VerifyNestedFlexBuffer(flex(), verifier) && + VerifyOffset(verifier, VT_TEST5) && + verifier.VerifyVector(test5()) && + VerifyOffset(verifier, VT_VECTOR_OF_LONGS) && + verifier.VerifyVector(vector_of_longs()) && + VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) && + verifier.VerifyVector(vector_of_doubles()) && + VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) && + verifier.VerifyTable(parent_namespace_test()) && + VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) && + verifier.VerifyVector(vector_of_referrables()) && + verifier.VerifyVectorOfTables(vector_of_referrables()) && + VerifyField(verifier, VT_SINGLE_WEAK_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) && + verifier.VerifyVector(vector_of_weak_references()) && + VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) && + verifier.VerifyVector(vector_of_strong_referrables()) && + verifier.VerifyVectorOfTables(vector_of_strong_referrables()) && + VerifyField(verifier, VT_CO_OWNING_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) && + verifier.VerifyVector(vector_of_co_owning_references()) && + VerifyField(verifier, VT_NON_OWNING_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) && + verifier.VerifyVector(vector_of_non_owning_references()) && + VerifyField(verifier, VT_ANY_UNIQUE_TYPE, 1) && + VerifyOffset(verifier, VT_ANY_UNIQUE) && + VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) && + VerifyField(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) && + VerifyOffset(verifier, VT_ANY_AMBIGUOUS) && + VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) && + VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) && + verifier.VerifyVector(vector_of_enums()) && + VerifyField(verifier, VT_SIGNED_ENUM, 1) && + VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) && + verifier.VerifyVector(testrequirednestedflatbuffer()) && + verifier.VerifyNestedFlatBuffer(testrequirednestedflatbuffer(), nullptr) && + VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) && + verifier.VerifyVector(scalar_key_sorted_tables()) && + verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) && + VerifyField(verifier, VT_NATIVE_INLINE, 2) && + VerifyField(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) && + VerifyField(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) && + verifier.EndTable(); + } + MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +template<> inline const MyGame::Example::Monster *Monster::test_as() const { + return test_as_Monster(); +} + +template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as() const { + return test_as_TestSimpleTableWithEnum(); +} + +template<> inline const MyGame::Example2::Monster *Monster::test_as() const { + return test_as_MyGame_Example2_Monster(); +} + +template<> inline const MyGame::Example::Monster *Monster::any_unique_as() const { + return any_unique_as_M(); +} + +template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as() const { + return any_unique_as_TS(); +} + +template<> inline const MyGame::Example2::Monster *Monster::any_unique_as() const { + return any_unique_as_M2(); +} + +struct MonsterBuilder { + typedef Monster Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pos(const MyGame::Example::Vec3 *pos) { + fbb_.AddStruct(Monster::VT_POS, pos); + } + void add_mana(int16_t mana) { + fbb_.AddElement(Monster::VT_MANA, mana, 150); + } + void add_hp(int16_t hp) { + fbb_.AddElement(Monster::VT_HP, hp, 100); + } + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(Monster::VT_NAME, name); + } + void add_inventory(flatbuffers::Offset> inventory) { + fbb_.AddOffset(Monster::VT_INVENTORY, inventory); + } + void add_color(MyGame::Example::Color color) { + fbb_.AddElement(Monster::VT_COLOR, static_cast(color), 8); + } + void add_test_type(MyGame::Example::Any test_type) { + fbb_.AddElement(Monster::VT_TEST_TYPE, static_cast(test_type), 0); + } + void add_test(flatbuffers::Offset test) { + fbb_.AddOffset(Monster::VT_TEST, test); + } + void add_test4(flatbuffers::Offset> test4) { + fbb_.AddOffset(Monster::VT_TEST4, test4); + } + void add_testarrayofstring(flatbuffers::Offset>> testarrayofstring) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); + } + void add_testarrayoftables(flatbuffers::Offset>> testarrayoftables) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); + } + void add_enemy(flatbuffers::Offset enemy) { + fbb_.AddOffset(Monster::VT_ENEMY, enemy); + } + void add_testnestedflatbuffer(flatbuffers::Offset> testnestedflatbuffer) { + fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); + } + void add_testempty(flatbuffers::Offset testempty) { + fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty); + } + void add_testbool(bool testbool) { + fbb_.AddElement(Monster::VT_TESTBOOL, static_cast(testbool), 0); + } + void add_testhashs32_fnv1(int32_t testhashs32_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0); + } + void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0); + } + void add_testhashs64_fnv1(int64_t testhashs64_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0); + } + void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0); + } + void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0); + } + void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0); + } + void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0); + } + void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0); + } + void add_testarrayofbools(flatbuffers::Offset> testarrayofbools) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools); + } + void add_testf(float testf) { + fbb_.AddElement(Monster::VT_TESTF, testf, 3.14159f); + } + void add_testf2(float testf2) { + fbb_.AddElement(Monster::VT_TESTF2, testf2, 3.0f); + } + void add_testf3(float testf3) { + fbb_.AddElement(Monster::VT_TESTF3, testf3, 0.0f); + } + void add_testarrayofstring2(flatbuffers::Offset>> testarrayofstring2) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); + } + void add_testarrayofsortedstruct(flatbuffers::Offset> testarrayofsortedstruct) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); + } + void add_flex(flatbuffers::Offset> flex) { + fbb_.AddOffset(Monster::VT_FLEX, flex); + } + void add_test5(flatbuffers::Offset> test5) { + fbb_.AddOffset(Monster::VT_TEST5, test5); + } + void add_vector_of_longs(flatbuffers::Offset> vector_of_longs) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); + } + void add_vector_of_doubles(flatbuffers::Offset> vector_of_doubles) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles); + } + void add_parent_namespace_test(flatbuffers::Offset parent_namespace_test) { + fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); + } + void add_vector_of_referrables(flatbuffers::Offset>> vector_of_referrables) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables); + } + void add_single_weak_reference(uint64_t single_weak_reference) { + fbb_.AddElement(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0); + } + void add_vector_of_weak_references(flatbuffers::Offset> vector_of_weak_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references); + } + void add_vector_of_strong_referrables(flatbuffers::Offset>> vector_of_strong_referrables) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables); + } + void add_co_owning_reference(uint64_t co_owning_reference) { + fbb_.AddElement(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0); + } + void add_vector_of_co_owning_references(flatbuffers::Offset> vector_of_co_owning_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references); + } + void add_non_owning_reference(uint64_t non_owning_reference) { + fbb_.AddElement(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0); + } + void add_vector_of_non_owning_references(flatbuffers::Offset> vector_of_non_owning_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references); + } + void add_any_unique_type(MyGame::Example::AnyUniqueAliases any_unique_type) { + fbb_.AddElement(Monster::VT_ANY_UNIQUE_TYPE, static_cast(any_unique_type), 0); + } + void add_any_unique(flatbuffers::Offset any_unique) { + fbb_.AddOffset(Monster::VT_ANY_UNIQUE, any_unique); + } + void add_any_ambiguous_type(MyGame::Example::AnyAmbiguousAliases any_ambiguous_type) { + fbb_.AddElement(Monster::VT_ANY_AMBIGUOUS_TYPE, static_cast(any_ambiguous_type), 0); + } + void add_any_ambiguous(flatbuffers::Offset any_ambiguous) { + fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); + } + void add_vector_of_enums(flatbuffers::Offset> vector_of_enums) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums); + } + void add_signed_enum(MyGame::Example::Race signed_enum) { + fbb_.AddElement(Monster::VT_SIGNED_ENUM, static_cast(signed_enum), -1); + } + void add_testrequirednestedflatbuffer(flatbuffers::Offset> testrequirednestedflatbuffer) { + fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); + } + void add_scalar_key_sorted_tables(flatbuffers::Offset>> scalar_key_sorted_tables) { + fbb_.AddOffset(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); + } + void add_native_inline(const MyGame::Example::Test *native_inline) { + fbb_.AddStruct(Monster::VT_NATIVE_INLINE, native_inline); + } + void add_long_enum_non_enum_default(MyGame::Example::LongEnum long_enum_non_enum_default) { + fbb_.AddElement(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast(long_enum_non_enum_default), 0); + } + void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) { + fbb_.AddElement(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast(long_enum_normal_default), 2ULL); + } + explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Monster::VT_NAME); + return o; + } +}; + +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb, + const MyGame::Example::Vec3 *pos = nullptr, + int16_t mana = 150, + int16_t hp = 100, + flatbuffers::Offset name = 0, + flatbuffers::Offset> inventory = 0, + MyGame::Example::Color color = MyGame::Example::Color_Blue, + MyGame::Example::Any test_type = MyGame::Example::Any_NONE, + flatbuffers::Offset test = 0, + flatbuffers::Offset> test4 = 0, + flatbuffers::Offset>> testarrayofstring = 0, + flatbuffers::Offset>> testarrayoftables = 0, + flatbuffers::Offset enemy = 0, + flatbuffers::Offset> testnestedflatbuffer = 0, + flatbuffers::Offset testempty = 0, + bool testbool = false, + int32_t testhashs32_fnv1 = 0, + uint32_t testhashu32_fnv1 = 0, + int64_t testhashs64_fnv1 = 0, + uint64_t testhashu64_fnv1 = 0, + int32_t testhashs32_fnv1a = 0, + uint32_t testhashu32_fnv1a = 0, + int64_t testhashs64_fnv1a = 0, + uint64_t testhashu64_fnv1a = 0, + flatbuffers::Offset> testarrayofbools = 0, + float testf = 3.14159f, + float testf2 = 3.0f, + float testf3 = 0.0f, + flatbuffers::Offset>> testarrayofstring2 = 0, + flatbuffers::Offset> testarrayofsortedstruct = 0, + flatbuffers::Offset> flex = 0, + flatbuffers::Offset> test5 = 0, + flatbuffers::Offset> vector_of_longs = 0, + flatbuffers::Offset> vector_of_doubles = 0, + flatbuffers::Offset parent_namespace_test = 0, + flatbuffers::Offset>> vector_of_referrables = 0, + uint64_t single_weak_reference = 0, + flatbuffers::Offset> vector_of_weak_references = 0, + flatbuffers::Offset>> vector_of_strong_referrables = 0, + uint64_t co_owning_reference = 0, + flatbuffers::Offset> vector_of_co_owning_references = 0, + uint64_t non_owning_reference = 0, + flatbuffers::Offset> vector_of_non_owning_references = 0, + MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE, + flatbuffers::Offset any_unique = 0, + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE, + flatbuffers::Offset any_ambiguous = 0, + flatbuffers::Offset> vector_of_enums = 0, + MyGame::Example::Race signed_enum = MyGame::Example::Race_None, + flatbuffers::Offset> testrequirednestedflatbuffer = 0, + flatbuffers::Offset>> scalar_key_sorted_tables = 0, + const MyGame::Example::Test *native_inline = nullptr, + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0), + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) { + MonsterBuilder builder_(_fbb); + builder_.add_long_enum_normal_default(long_enum_normal_default); + builder_.add_long_enum_non_enum_default(long_enum_non_enum_default); + builder_.add_non_owning_reference(non_owning_reference); + builder_.add_co_owning_reference(co_owning_reference); + builder_.add_single_weak_reference(single_weak_reference); + builder_.add_testhashu64_fnv1a(testhashu64_fnv1a); + builder_.add_testhashs64_fnv1a(testhashs64_fnv1a); + builder_.add_testhashu64_fnv1(testhashu64_fnv1); + builder_.add_testhashs64_fnv1(testhashs64_fnv1); + builder_.add_native_inline(native_inline); + builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables); + builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer); + builder_.add_vector_of_enums(vector_of_enums); + builder_.add_any_ambiguous(any_ambiguous); + builder_.add_any_unique(any_unique); + builder_.add_vector_of_non_owning_references(vector_of_non_owning_references); + builder_.add_vector_of_co_owning_references(vector_of_co_owning_references); + builder_.add_vector_of_strong_referrables(vector_of_strong_referrables); + builder_.add_vector_of_weak_references(vector_of_weak_references); + builder_.add_vector_of_referrables(vector_of_referrables); + builder_.add_parent_namespace_test(parent_namespace_test); + builder_.add_vector_of_doubles(vector_of_doubles); + builder_.add_vector_of_longs(vector_of_longs); + builder_.add_test5(test5); + builder_.add_flex(flex); + builder_.add_testarrayofsortedstruct(testarrayofsortedstruct); + builder_.add_testarrayofstring2(testarrayofstring2); + builder_.add_testf3(testf3); + builder_.add_testf2(testf2); + builder_.add_testf(testf); + builder_.add_testarrayofbools(testarrayofbools); + builder_.add_testhashu32_fnv1a(testhashu32_fnv1a); + builder_.add_testhashs32_fnv1a(testhashs32_fnv1a); + builder_.add_testhashu32_fnv1(testhashu32_fnv1); + builder_.add_testhashs32_fnv1(testhashs32_fnv1); + builder_.add_testempty(testempty); + builder_.add_testnestedflatbuffer(testnestedflatbuffer); + builder_.add_enemy(enemy); + builder_.add_testarrayoftables(testarrayoftables); + builder_.add_testarrayofstring(testarrayofstring); + builder_.add_test4(test4); + builder_.add_test(test); + builder_.add_inventory(inventory); + builder_.add_name(name); + builder_.add_pos(pos); + builder_.add_hp(hp); + builder_.add_mana(mana); + builder_.add_signed_enum(signed_enum); + builder_.add_any_ambiguous_type(any_ambiguous_type); + builder_.add_any_unique_type(any_unique_type); + builder_.add_testbool(testbool); + builder_.add_test_type(test_type); + builder_.add_color(color); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateMonsterDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const MyGame::Example::Vec3 *pos = nullptr, + int16_t mana = 150, + int16_t hp = 100, + const char *name = nullptr, + const std::vector *inventory = nullptr, + MyGame::Example::Color color = MyGame::Example::Color_Blue, + MyGame::Example::Any test_type = MyGame::Example::Any_NONE, + flatbuffers::Offset test = 0, + const std::vector *test4 = nullptr, + const std::vector> *testarrayofstring = nullptr, + std::vector> *testarrayoftables = nullptr, + flatbuffers::Offset enemy = 0, + const std::vector *testnestedflatbuffer = nullptr, + flatbuffers::Offset testempty = 0, + bool testbool = false, + int32_t testhashs32_fnv1 = 0, + uint32_t testhashu32_fnv1 = 0, + int64_t testhashs64_fnv1 = 0, + uint64_t testhashu64_fnv1 = 0, + int32_t testhashs32_fnv1a = 0, + uint32_t testhashu32_fnv1a = 0, + int64_t testhashs64_fnv1a = 0, + uint64_t testhashu64_fnv1a = 0, + const std::vector *testarrayofbools = nullptr, + float testf = 3.14159f, + float testf2 = 3.0f, + float testf3 = 0.0f, + const std::vector> *testarrayofstring2 = nullptr, + std::vector *testarrayofsortedstruct = nullptr, + const std::vector *flex = nullptr, + const std::vector *test5 = nullptr, + const std::vector *vector_of_longs = nullptr, + const std::vector *vector_of_doubles = nullptr, + flatbuffers::Offset parent_namespace_test = 0, + std::vector> *vector_of_referrables = nullptr, + uint64_t single_weak_reference = 0, + const std::vector *vector_of_weak_references = nullptr, + std::vector> *vector_of_strong_referrables = nullptr, + uint64_t co_owning_reference = 0, + const std::vector *vector_of_co_owning_references = nullptr, + uint64_t non_owning_reference = 0, + const std::vector *vector_of_non_owning_references = nullptr, + MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE, + flatbuffers::Offset any_unique = 0, + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE, + flatbuffers::Offset any_ambiguous = 0, + const std::vector *vector_of_enums = nullptr, + MyGame::Example::Race signed_enum = MyGame::Example::Race_None, + const std::vector *testrequirednestedflatbuffer = nullptr, + std::vector> *scalar_key_sorted_tables = nullptr, + const MyGame::Example::Test *native_inline = nullptr, + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0), + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto inventory__ = inventory ? _fbb.CreateVector(*inventory) : 0; + auto test4__ = test4 ? _fbb.CreateVectorOfStructs(*test4) : 0; + auto testarrayofstring__ = testarrayofstring ? _fbb.CreateVector>(*testarrayofstring) : 0; + auto testarrayoftables__ = testarrayoftables ? _fbb.CreateVectorOfSortedTables(testarrayoftables) : 0; + auto testnestedflatbuffer__ = testnestedflatbuffer ? _fbb.CreateVector(*testnestedflatbuffer) : 0; + auto testarrayofbools__ = testarrayofbools ? _fbb.CreateVector(*testarrayofbools) : 0; + auto testarrayofstring2__ = testarrayofstring2 ? _fbb.CreateVector>(*testarrayofstring2) : 0; + auto testarrayofsortedstruct__ = testarrayofsortedstruct ? _fbb.CreateVectorOfSortedStructs(testarrayofsortedstruct) : 0; + auto flex__ = flex ? _fbb.CreateVector(*flex) : 0; + auto test5__ = test5 ? _fbb.CreateVectorOfStructs(*test5) : 0; + auto vector_of_longs__ = vector_of_longs ? _fbb.CreateVector(*vector_of_longs) : 0; + auto vector_of_doubles__ = vector_of_doubles ? _fbb.CreateVector(*vector_of_doubles) : 0; + auto vector_of_referrables__ = vector_of_referrables ? _fbb.CreateVectorOfSortedTables(vector_of_referrables) : 0; + auto vector_of_weak_references__ = vector_of_weak_references ? _fbb.CreateVector(*vector_of_weak_references) : 0; + auto vector_of_strong_referrables__ = vector_of_strong_referrables ? _fbb.CreateVectorOfSortedTables(vector_of_strong_referrables) : 0; + auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector(*vector_of_co_owning_references) : 0; + auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector(*vector_of_non_owning_references) : 0; + auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector(*vector_of_enums) : 0; + auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector(*testrequirednestedflatbuffer) : 0; + auto scalar_key_sorted_tables__ = scalar_key_sorted_tables ? _fbb.CreateVectorOfSortedTables(scalar_key_sorted_tables) : 0; + return MyGame::Example::CreateMonster( + _fbb, + pos, + mana, + hp, + name__, + inventory__, + color, + test_type, + test, + test4__, + testarrayofstring__, + testarrayoftables__, + enemy, + testnestedflatbuffer__, + testempty, + testbool, + testhashs32_fnv1, + testhashu32_fnv1, + testhashs64_fnv1, + testhashu64_fnv1, + testhashs32_fnv1a, + testhashu32_fnv1a, + testhashs64_fnv1a, + testhashu64_fnv1a, + testarrayofbools__, + testf, + testf2, + testf3, + testarrayofstring2__, + testarrayofsortedstruct__, + flex__, + test5__, + vector_of_longs__, + vector_of_doubles__, + parent_namespace_test, + vector_of_referrables__, + single_weak_reference, + vector_of_weak_references__, + vector_of_strong_referrables__, + co_owning_reference, + vector_of_co_owning_references__, + non_owning_reference, + vector_of_non_owning_references__, + any_unique_type, + any_unique, + any_ambiguous_type, + any_ambiguous, + vector_of_enums__, + signed_enum, + testrequirednestedflatbuffer__, + scalar_key_sorted_tables__, + native_inline, + long_enum_non_enum_default, + long_enum_normal_default); +} + +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct TypeAliasesT : public flatbuffers::NativeTable { + typedef TypeAliases TableType; + int8_t i8 = 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; + std::vector v8{}; + std::vector vf64{}; +}; + +struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TypeAliasesT NativeTableType; + typedef TypeAliasesBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TypeAliasesTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_I8 = 4, + VT_U8 = 6, + VT_I16 = 8, + VT_U16 = 10, + VT_I32 = 12, + VT_U32 = 14, + VT_I64 = 16, + VT_U64 = 18, + VT_F32 = 20, + VT_F64 = 22, + VT_V8 = 24, + VT_VF64 = 26 + }; + int8_t i8() const { + return GetField(VT_I8, 0); + } + bool mutate_i8(int8_t _i8 = 0) { + return SetField(VT_I8, _i8, 0); + } + uint8_t u8() const { + return GetField(VT_U8, 0); + } + bool mutate_u8(uint8_t _u8 = 0) { + return SetField(VT_U8, _u8, 0); + } + int16_t i16() const { + return GetField(VT_I16, 0); + } + bool mutate_i16(int16_t _i16 = 0) { + return SetField(VT_I16, _i16, 0); + } + uint16_t u16() const { + return GetField(VT_U16, 0); + } + bool mutate_u16(uint16_t _u16 = 0) { + return SetField(VT_U16, _u16, 0); + } + int32_t i32() const { + return GetField(VT_I32, 0); + } + bool mutate_i32(int32_t _i32 = 0) { + return SetField(VT_I32, _i32, 0); + } + uint32_t u32() const { + return GetField(VT_U32, 0); + } + bool mutate_u32(uint32_t _u32 = 0) { + return SetField(VT_U32, _u32, 0); + } + int64_t i64() const { + return GetField(VT_I64, 0); + } + bool mutate_i64(int64_t _i64 = 0) { + return SetField(VT_I64, _i64, 0); + } + uint64_t u64() const { + return GetField(VT_U64, 0); + } + bool mutate_u64(uint64_t _u64 = 0) { + return SetField(VT_U64, _u64, 0); + } + float f32() const { + return GetField(VT_F32, 0.0f); + } + bool mutate_f32(float _f32 = 0.0f) { + return SetField(VT_F32, _f32, 0.0f); + } + double f64() const { + return GetField(VT_F64, 0.0); + } + bool mutate_f64(double _f64 = 0.0) { + return SetField(VT_F64, _f64, 0.0); + } + const flatbuffers::Vector *v8() const { + return GetPointer *>(VT_V8); + } + flatbuffers::Vector *mutable_v8() { + return GetPointer *>(VT_V8); + } + const flatbuffers::Vector *vf64() const { + return GetPointer *>(VT_VF64); + } + flatbuffers::Vector *mutable_vf64() { + return GetPointer *>(VT_VF64); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_I8, 1) && + VerifyField(verifier, VT_U8, 1) && + VerifyField(verifier, VT_I16, 2) && + VerifyField(verifier, VT_U16, 2) && + VerifyField(verifier, VT_I32, 4) && + VerifyField(verifier, VT_U32, 4) && + VerifyField(verifier, VT_I64, 8) && + VerifyField(verifier, VT_U64, 8) && + VerifyField(verifier, VT_F32, 4) && + VerifyField(verifier, VT_F64, 8) && + VerifyOffset(verifier, VT_V8) && + verifier.VerifyVector(v8()) && + VerifyOffset(verifier, VT_VF64) && + verifier.VerifyVector(vf64()) && + verifier.EndTable(); + } + TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TypeAliasesBuilder { + typedef TypeAliases Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_i8(int8_t i8) { + fbb_.AddElement(TypeAliases::VT_I8, i8, 0); + } + void add_u8(uint8_t u8) { + fbb_.AddElement(TypeAliases::VT_U8, u8, 0); + } + void add_i16(int16_t i16) { + fbb_.AddElement(TypeAliases::VT_I16, i16, 0); + } + void add_u16(uint16_t u16) { + fbb_.AddElement(TypeAliases::VT_U16, u16, 0); + } + void add_i32(int32_t i32) { + fbb_.AddElement(TypeAliases::VT_I32, i32, 0); + } + void add_u32(uint32_t u32) { + fbb_.AddElement(TypeAliases::VT_U32, u32, 0); + } + void add_i64(int64_t i64) { + fbb_.AddElement(TypeAliases::VT_I64, i64, 0); + } + void add_u64(uint64_t u64) { + fbb_.AddElement(TypeAliases::VT_U64, u64, 0); + } + void add_f32(float f32) { + fbb_.AddElement(TypeAliases::VT_F32, f32, 0.0f); + } + void add_f64(double f64) { + fbb_.AddElement(TypeAliases::VT_F64, f64, 0.0); + } + void add_v8(flatbuffers::Offset> v8) { + fbb_.AddOffset(TypeAliases::VT_V8, v8); + } + void add_vf64(flatbuffers::Offset> vf64) { + fbb_.AddOffset(TypeAliases::VT_VF64, vf64); + } + explicit TypeAliasesBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTypeAliases( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + flatbuffers::Offset> v8 = 0, + flatbuffers::Offset> vf64 = 0) { + TypeAliasesBuilder builder_(_fbb); + builder_.add_f64(f64); + builder_.add_u64(u64); + builder_.add_i64(i64); + builder_.add_vf64(vf64); + builder_.add_v8(v8); + builder_.add_f32(f32); + builder_.add_u32(u32); + builder_.add_i32(i32); + builder_.add_u16(u16); + builder_.add_i16(i16); + builder_.add_u8(u8); + builder_.add_i8(i8); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTypeAliasesDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + const std::vector *v8 = nullptr, + const std::vector *vf64 = nullptr) { + auto v8__ = v8 ? _fbb.CreateVector(*v8) : 0; + auto vf64__ = vf64 ? _fbb.CreateVector(*vf64) : 0; + return MyGame::Example::CreateTypeAliases( + _fbb, + i8, + u8, + i16, + u16, + i32, + u32, + i64, + u64, + f32, + f64, + v8__, + vf64__); +} + +flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +} // namespace Example + + +inline bool operator==(const InParentNamespaceT &, const InParentNamespaceT &) { + return true; +} + +inline bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs) { + return !(lhs == rhs); +} + + +inline InParentNamespaceT *InParentNamespace::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new InParentNamespaceT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; +} + +inline flatbuffers::Offset InParentNamespace::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateInParentNamespace(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InParentNamespaceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return MyGame::CreateInParentNamespace( + _fbb); +} + +namespace Example2 { + + +inline bool operator==(const MonsterT &, const MonsterT &) { + return true; +} + +inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { + return !(lhs == rhs); +} + + +inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new MonsterT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; +} + +inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateMonster(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return MyGame::Example2::CreateMonster( + _fbb); +} + +} // namespace Example2 + +namespace Example { + + +inline bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { + return + (lhs.color == rhs.color); +} + +inline bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { + return !(lhs == rhs); +} + + +inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new TestSimpleTableWithEnumT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = color(); _o->color = _e; } +} + +inline flatbuffers::Offset TestSimpleTableWithEnum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TestSimpleTableWithEnumT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _color = _o->color; + return MyGame::Example::CreateTestSimpleTableWithEnum( + _fbb, + _color); +} + + +inline bool operator==(const StatT &lhs, const StatT &rhs) { + return + (lhs.id == rhs.id) && + (lhs.val == rhs.val) && + (lhs.count == rhs.count); +} + +inline bool operator!=(const StatT &lhs, const StatT &rhs) { + return !(lhs == rhs); +} + + +inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new StatT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Stat::UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); if (_e) _o->id = _e->str(); } + { auto _e = val(); _o->val = _e; } + { auto _e = count(); _o->count = _e; } +} + +inline flatbuffers::Offset Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateStat(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id.empty() ? 0 : _fbb.CreateString(_o->id); + auto _val = _o->val; + auto _count = _o->count; + return MyGame::Example::CreateStat( + _fbb, + _id, + _val, + _count); +} + + +inline bool operator==(const ReferrableT &lhs, const ReferrableT &rhs) { + return + (lhs.id == rhs.id); +} + +inline bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs) { + return !(lhs == rhs); +} + + +inline ReferrableT *Referrable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ReferrableT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Referrable::UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); _o->id = _e; } +} + +inline flatbuffers::Offset Referrable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateReferrable(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id; + return MyGame::Example::CreateReferrable( + _fbb, + _id); +} + + +inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) { + return + ((lhs.pos == rhs.pos) || (lhs.pos && rhs.pos && *lhs.pos == *rhs.pos)) && + (lhs.mana == rhs.mana) && + (lhs.hp == rhs.hp) && + (lhs.name == rhs.name) && + (lhs.inventory == rhs.inventory) && + (lhs.color == rhs.color) && + (lhs.test == rhs.test) && + (lhs.test4 == rhs.test4) && + (lhs.testarrayofstring == rhs.testarrayofstring) && + (lhs.testarrayoftables == rhs.testarrayoftables) && + ((lhs.enemy == rhs.enemy) || (lhs.enemy && rhs.enemy && *lhs.enemy == *rhs.enemy)) && + (lhs.testnestedflatbuffer == rhs.testnestedflatbuffer) && + ((lhs.testempty == rhs.testempty) || (lhs.testempty && rhs.testempty && *lhs.testempty == *rhs.testempty)) && + (lhs.testbool == rhs.testbool) && + (lhs.testhashs32_fnv1 == rhs.testhashs32_fnv1) && + (lhs.testhashu32_fnv1 == rhs.testhashu32_fnv1) && + (lhs.testhashs64_fnv1 == rhs.testhashs64_fnv1) && + (lhs.testhashu64_fnv1 == rhs.testhashu64_fnv1) && + (lhs.testhashs32_fnv1a == rhs.testhashs32_fnv1a) && + (lhs.testhashu32_fnv1a == rhs.testhashu32_fnv1a) && + (lhs.testhashs64_fnv1a == rhs.testhashs64_fnv1a) && + (lhs.testhashu64_fnv1a == rhs.testhashu64_fnv1a) && + (lhs.testarrayofbools == rhs.testarrayofbools) && + (lhs.testf == rhs.testf) && + (lhs.testf2 == rhs.testf2) && + (lhs.testf3 == rhs.testf3) && + (lhs.testarrayofstring2 == rhs.testarrayofstring2) && + (lhs.testarrayofsortedstruct == rhs.testarrayofsortedstruct) && + (lhs.flex == rhs.flex) && + (lhs.test5 == rhs.test5) && + (lhs.vector_of_longs == rhs.vector_of_longs) && + (lhs.vector_of_doubles == rhs.vector_of_doubles) && + ((lhs.parent_namespace_test == rhs.parent_namespace_test) || (lhs.parent_namespace_test && rhs.parent_namespace_test && *lhs.parent_namespace_test == *rhs.parent_namespace_test)) && + (lhs.vector_of_referrables == rhs.vector_of_referrables) && + (lhs.single_weak_reference == rhs.single_weak_reference) && + (lhs.vector_of_weak_references == rhs.vector_of_weak_references) && + (lhs.vector_of_strong_referrables == rhs.vector_of_strong_referrables) && + (lhs.co_owning_reference == rhs.co_owning_reference) && + (lhs.vector_of_co_owning_references == rhs.vector_of_co_owning_references) && + (lhs.non_owning_reference == rhs.non_owning_reference) && + (lhs.vector_of_non_owning_references == rhs.vector_of_non_owning_references) && + (lhs.any_unique == rhs.any_unique) && + (lhs.any_ambiguous == rhs.any_ambiguous) && + (lhs.vector_of_enums == rhs.vector_of_enums) && + (lhs.signed_enum == rhs.signed_enum) && + (lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer) && + (lhs.scalar_key_sorted_tables == rhs.scalar_key_sorted_tables) && + (lhs.native_inline == rhs.native_inline) && + (lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) && + (lhs.long_enum_normal_default == rhs.long_enum_normal_default); +} + +inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { + return !(lhs == rhs); +} + + +inline MonsterT::MonsterT(const MonsterT &o) + : pos((o.pos) ? new MyGame::Example::Vec3(*o.pos) : nullptr), + mana(o.mana), + hp(o.hp), + name(o.name), + inventory(o.inventory), + color(o.color), + test(o.test), + test4(o.test4), + testarrayofstring(o.testarrayofstring), + enemy((o.enemy) ? new MyGame::Example::MonsterT(*o.enemy) : nullptr), + testnestedflatbuffer(o.testnestedflatbuffer), + testempty((o.testempty) ? new MyGame::Example::StatT(*o.testempty) : nullptr), + testbool(o.testbool), + testhashs32_fnv1(o.testhashs32_fnv1), + testhashu32_fnv1(o.testhashu32_fnv1), + testhashs64_fnv1(o.testhashs64_fnv1), + testhashu64_fnv1(o.testhashu64_fnv1), + testhashs32_fnv1a(o.testhashs32_fnv1a), + testhashu32_fnv1a(o.testhashu32_fnv1a), + testhashs64_fnv1a(o.testhashs64_fnv1a), + testhashu64_fnv1a(o.testhashu64_fnv1a), + testarrayofbools(o.testarrayofbools), + testf(o.testf), + testf2(o.testf2), + testf3(o.testf3), + testarrayofstring2(o.testarrayofstring2), + testarrayofsortedstruct(o.testarrayofsortedstruct), + flex(o.flex), + test5(o.test5), + vector_of_longs(o.vector_of_longs), + vector_of_doubles(o.vector_of_doubles), + parent_namespace_test((o.parent_namespace_test) ? new MyGame::InParentNamespaceT(*o.parent_namespace_test) : nullptr), + single_weak_reference(o.single_weak_reference), + vector_of_weak_references(o.vector_of_weak_references), + co_owning_reference(o.co_owning_reference), + non_owning_reference(o.non_owning_reference), + vector_of_non_owning_references(o.vector_of_non_owning_references), + any_unique(o.any_unique), + any_ambiguous(o.any_ambiguous), + vector_of_enums(o.vector_of_enums), + signed_enum(o.signed_enum), + testrequirednestedflatbuffer(o.testrequirednestedflatbuffer), + native_inline(o.native_inline), + long_enum_non_enum_default(o.long_enum_non_enum_default), + long_enum_normal_default(o.long_enum_normal_default) { + testarrayoftables.reserve(o.testarrayoftables.size()); + for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); } + vector_of_referrables.reserve(o.vector_of_referrables.size()); + for (const auto &vector_of_referrables_ : o.vector_of_referrables) { vector_of_referrables.emplace_back((vector_of_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_referrables_) : nullptr); } + vector_of_strong_referrables.reserve(o.vector_of_strong_referrables.size()); + for (const auto &vector_of_strong_referrables_ : o.vector_of_strong_referrables) { vector_of_strong_referrables.emplace_back((vector_of_strong_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_strong_referrables_) : nullptr); } + vector_of_co_owning_references.reserve(o.vector_of_co_owning_references.size()); + for (const auto &vector_of_co_owning_references_ : o.vector_of_co_owning_references) { vector_of_co_owning_references.emplace_back((vector_of_co_owning_references_) ? new ReferrableT(*vector_of_co_owning_references_) : nullptr); } + scalar_key_sorted_tables.reserve(o.scalar_key_sorted_tables.size()); + for (const auto &scalar_key_sorted_tables_ : o.scalar_key_sorted_tables) { scalar_key_sorted_tables.emplace_back((scalar_key_sorted_tables_) ? new MyGame::Example::StatT(*scalar_key_sorted_tables_) : nullptr); } +} + +inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT { + std::swap(pos, o.pos); + std::swap(mana, o.mana); + std::swap(hp, o.hp); + std::swap(name, o.name); + std::swap(inventory, o.inventory); + std::swap(color, o.color); + std::swap(test, o.test); + std::swap(test4, o.test4); + std::swap(testarrayofstring, o.testarrayofstring); + std::swap(testarrayoftables, o.testarrayoftables); + std::swap(enemy, o.enemy); + std::swap(testnestedflatbuffer, o.testnestedflatbuffer); + std::swap(testempty, o.testempty); + std::swap(testbool, o.testbool); + std::swap(testhashs32_fnv1, o.testhashs32_fnv1); + std::swap(testhashu32_fnv1, o.testhashu32_fnv1); + std::swap(testhashs64_fnv1, o.testhashs64_fnv1); + std::swap(testhashu64_fnv1, o.testhashu64_fnv1); + std::swap(testhashs32_fnv1a, o.testhashs32_fnv1a); + std::swap(testhashu32_fnv1a, o.testhashu32_fnv1a); + std::swap(testhashs64_fnv1a, o.testhashs64_fnv1a); + std::swap(testhashu64_fnv1a, o.testhashu64_fnv1a); + std::swap(testarrayofbools, o.testarrayofbools); + std::swap(testf, o.testf); + std::swap(testf2, o.testf2); + std::swap(testf3, o.testf3); + std::swap(testarrayofstring2, o.testarrayofstring2); + std::swap(testarrayofsortedstruct, o.testarrayofsortedstruct); + std::swap(flex, o.flex); + std::swap(test5, o.test5); + std::swap(vector_of_longs, o.vector_of_longs); + std::swap(vector_of_doubles, o.vector_of_doubles); + std::swap(parent_namespace_test, o.parent_namespace_test); + std::swap(vector_of_referrables, o.vector_of_referrables); + std::swap(single_weak_reference, o.single_weak_reference); + std::swap(vector_of_weak_references, o.vector_of_weak_references); + std::swap(vector_of_strong_referrables, o.vector_of_strong_referrables); + std::swap(co_owning_reference, o.co_owning_reference); + std::swap(vector_of_co_owning_references, o.vector_of_co_owning_references); + std::swap(non_owning_reference, o.non_owning_reference); + std::swap(vector_of_non_owning_references, o.vector_of_non_owning_references); + std::swap(any_unique, o.any_unique); + std::swap(any_ambiguous, o.any_ambiguous); + std::swap(vector_of_enums, o.vector_of_enums); + std::swap(signed_enum, o.signed_enum); + std::swap(testrequirednestedflatbuffer, o.testrequirednestedflatbuffer); + std::swap(scalar_key_sorted_tables, o.scalar_key_sorted_tables); + std::swap(native_inline, o.native_inline); + std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default); + std::swap(long_enum_normal_default, o.long_enum_normal_default); + return *this; +} + +inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new MonsterT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr(new MyGame::Example::Vec3(*_e)); } + { auto _e = mana(); _o->mana = _e; } + { auto _e = hp(); _o->hp = _e; } + { auto _e = name(); if (_e) _o->name = _e->str(); } + { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } } + { auto _e = color(); _o->color = _e; } + { auto _e = test_type(); _o->test.type = _e; } + { auto _e = test(); if (_e) _o->test.value = MyGame::Example::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++) { if(_o->testarrayoftables[_i]) { _e->Get(_i)->UnPackTo(_o->testarrayoftables[_i].get(), _resolver); } else { _o->testarrayoftables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = enemy(); if (_e) { if(_o->enemy) { _e->UnPackTo(_o->enemy.get(), _resolver); } else { _o->enemy = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testnestedflatbuffer.begin()); } } + { auto _e = testempty(); if (_e) { if(_o->testempty) { _e->UnPackTo(_o->testempty.get(), _resolver); } else { _o->testempty = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = testbool(); _o->testbool = _e; } + { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; } + { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; } + { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; } + { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; } + { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; } + { auto _e = testhashu32_fnv1a(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->testhashu32_fnv1a), static_cast(_e)); else _o->testhashu32_fnv1a = nullptr; } + { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; } + { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; } + { auto _e = testarrayofbools(); if (_e) { _o->testarrayofbools.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools[_i] = _e->Get(_i) != 0; } } } + { auto _e = testf(); _o->testf = _e; } + { auto _e = testf2(); _o->testf2 = _e; } + { auto _e = testf3(); _o->testf3 = _e; } + { auto _e = testarrayofstring2(); if (_e) { _o->testarrayofstring2.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2[_i] = _e->Get(_i)->str(); } } } + { auto _e = testarrayofsortedstruct(); if (_e) { _o->testarrayofsortedstruct.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofsortedstruct[_i] = *_e->Get(_i); } } } + { auto _e = flex(); if (_e) { _o->flex.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->flex.begin()); } } + { auto _e = test5(); if (_e) { _o->test5.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test5[_i] = *_e->Get(_i); } } } + { auto _e = vector_of_longs(); if (_e) { _o->vector_of_longs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_longs[_i] = _e->Get(_i); } } } + { auto _e = vector_of_doubles(); if (_e) { _o->vector_of_doubles.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_doubles[_i] = _e->Get(_i); } } } + { auto _e = parent_namespace_test(); if (_e) { if(_o->parent_namespace_test) { _e->UnPackTo(_o->parent_namespace_test.get(), _resolver); } else { _o->parent_namespace_test = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = vector_of_referrables(); if (_e) { _o->vector_of_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_referrables[_i].get(), _resolver); } else { _o->vector_of_referrables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = single_weak_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->single_weak_reference), static_cast(_e)); else _o->single_weak_reference = nullptr; } + { auto _e = vector_of_weak_references(); if (_e) { _o->vector_of_weak_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_weak_references[_i]), static_cast(_e->Get(_i))); else _o->vector_of_weak_references[_i] = nullptr; } } } + { auto _e = vector_of_strong_referrables(); if (_e) { _o->vector_of_strong_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_strong_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_strong_referrables[_i].get(), _resolver); } else { _o->vector_of_strong_referrables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = co_owning_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->co_owning_reference), static_cast(_e)); else _o->co_owning_reference = nullptr; } + { auto _e = vector_of_co_owning_references(); if (_e) { _o->vector_of_co_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, default_ptr_type +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_co_owning_references[_i]), static_cast(_e->Get(_i)));/* else do nothing */; } } } + { auto _e = non_owning_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->non_owning_reference), static_cast(_e)); else _o->non_owning_reference = nullptr; } + { auto _e = vector_of_non_owning_references(); if (_e) { _o->vector_of_non_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_non_owning_references[_i]), static_cast(_e->Get(_i))); else _o->vector_of_non_owning_references[_i] = nullptr; } } } + { auto _e = any_unique_type(); _o->any_unique.type = _e; } + { auto _e = any_unique(); if (_e) _o->any_unique.value = MyGame::Example::AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); } + { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; } + { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); } + { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast(_e->Get(_i)); } } } + { auto _e = signed_enum(); _o->signed_enum = _e; } + { auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } } + { auto _e = scalar_key_sorted_tables(); if (_e) { _o->scalar_key_sorted_tables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->scalar_key_sorted_tables[_i]) { _e->Get(_i)->UnPackTo(_o->scalar_key_sorted_tables[_i].get(), _resolver); } else { _o->scalar_key_sorted_tables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = native_inline(); if (_e) _o->native_inline = *_e; } + { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; } + { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; } +} + +inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateMonster(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _pos = _o->pos ? _o->pos.get() : 0; + auto _mana = _o->mana; + auto _hp = _o->hp; + auto _name = _fbb.CreateString(_o->name); + auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0; + auto _color = _o->color; + auto _test_type = _o->test.type; + auto _test = _o->test.Pack(_fbb); + auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0; + auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0; + auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0; + auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0; + auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0; + auto _testbool = _o->testbool; + auto _testhashs32_fnv1 = _o->testhashs32_fnv1; + auto _testhashu32_fnv1 = _o->testhashu32_fnv1; + auto _testhashs64_fnv1 = _o->testhashs64_fnv1; + auto _testhashu64_fnv1 = _o->testhashu64_fnv1; + auto _testhashs32_fnv1a = _o->testhashs32_fnv1a; + auto _testhashu32_fnv1a = _rehasher ? static_cast((*_rehasher)(_o->testhashu32_fnv1a)) : 0; + auto _testhashs64_fnv1a = _o->testhashs64_fnv1a; + auto _testhashu64_fnv1a = _o->testhashu64_fnv1a; + auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0; + auto _testf = _o->testf; + auto _testf2 = _o->testf2; + auto _testf3 = _o->testf3; + auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0; + auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0; + auto _flex = _o->flex.size() ? _fbb.CreateVector(_o->flex) : 0; + auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0; + auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0; + auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0; + auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0; + auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _single_weak_reference = _rehasher ? static_cast((*_rehasher)(_o->single_weak_reference)) : 0; + auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0; + auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _co_owning_reference = _rehasher ? static_cast((*_rehasher)(_o->co_owning_reference)) : 0; + auto _vector_of_co_owning_references = _o->vector_of_co_owning_references.size() ? _fbb.CreateVector(_o->vector_of_co_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_co_owning_references[i].get())) : 0; }, &_va ) : 0; + auto _non_owning_reference = _rehasher ? static_cast((*_rehasher)(_o->non_owning_reference)) : 0; + auto _vector_of_non_owning_references = _o->vector_of_non_owning_references.size() ? _fbb.CreateVector(_o->vector_of_non_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_non_owning_references[i])) : 0; }, &_va ) : 0; + auto _any_unique_type = _o->any_unique.type; + auto _any_unique = _o->any_unique.Pack(_fbb); + auto _any_ambiguous_type = _o->any_ambiguous.type; + auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb); + auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast(flatbuffers::data(_o->vector_of_enums), _o->vector_of_enums.size()) : 0; + auto _signed_enum = _o->signed_enum; + auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0; + auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _native_inline = &_o->native_inline; + auto _long_enum_non_enum_default = _o->long_enum_non_enum_default; + auto _long_enum_normal_default = _o->long_enum_normal_default; + return MyGame::Example::CreateMonster( + _fbb, + _pos, + _mana, + _hp, + _name, + _inventory, + _color, + _test_type, + _test, + _test4, + _testarrayofstring, + _testarrayoftables, + _enemy, + _testnestedflatbuffer, + _testempty, + _testbool, + _testhashs32_fnv1, + _testhashu32_fnv1, + _testhashs64_fnv1, + _testhashu64_fnv1, + _testhashs32_fnv1a, + _testhashu32_fnv1a, + _testhashs64_fnv1a, + _testhashu64_fnv1a, + _testarrayofbools, + _testf, + _testf2, + _testf3, + _testarrayofstring2, + _testarrayofsortedstruct, + _flex, + _test5, + _vector_of_longs, + _vector_of_doubles, + _parent_namespace_test, + _vector_of_referrables, + _single_weak_reference, + _vector_of_weak_references, + _vector_of_strong_referrables, + _co_owning_reference, + _vector_of_co_owning_references, + _non_owning_reference, + _vector_of_non_owning_references, + _any_unique_type, + _any_unique, + _any_ambiguous_type, + _any_ambiguous, + _vector_of_enums, + _signed_enum, + _testrequirednestedflatbuffer, + _scalar_key_sorted_tables, + _native_inline, + _long_enum_non_enum_default, + _long_enum_normal_default); +} + + +inline bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { + return + (lhs.i8 == rhs.i8) && + (lhs.u8 == rhs.u8) && + (lhs.i16 == rhs.i16) && + (lhs.u16 == rhs.u16) && + (lhs.i32 == rhs.i32) && + (lhs.u32 == rhs.u32) && + (lhs.i64 == rhs.i64) && + (lhs.u64 == rhs.u64) && + (lhs.f32 == rhs.f32) && + (lhs.f64 == rhs.f64) && + (lhs.v8 == rhs.v8) && + (lhs.vf64 == rhs.vf64); +} + +inline bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { + return !(lhs == rhs); +} + + +inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new TypeAliasesT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +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()); std::copy(_e->begin(), _e->end(), _o->v8.begin()); } } + { auto _e = vf64(); if (_e) { _o->vf64.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vf64[_i] = _e->Get(_i); } } } +} + +inline flatbuffers::Offset TypeAliases::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTypeAliases(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _i8 = _o->i8; + auto _u8 = _o->u8; + auto _i16 = _o->i16; + auto _u16 = _o->u16; + auto _i32 = _o->i32; + auto _u32 = _o->u32; + auto _i64 = _o->i64; + auto _u64 = _o->u64; + auto _f32 = _o->f32; + auto _f64 = _o->f64; + auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0; + auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0; + return MyGame::Example::CreateTypeAliases( + _fbb, + _i8, + _u8, + _i16, + _u16, + _i32, + _u32, + _i64, + _u64, + _f32, + _f64, + _v8, + _vf64); +} + +inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) { + switch (type) { + case Any_NONE: { + return true; + } + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAny( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(value); + return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyUnion::AnyUnion(const AnyUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case Any_Monster: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case Any_TestSimpleTableWithEnum: { + value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast(u.value)); + break; + } + case Any_MyGame_Example2_Monster: { + value = new MyGame::Example2::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyUnion::Reset() { + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = Any_NONE; +} + +inline bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) { + switch (type) { + case AnyUniqueAliases_NONE: { + return true; + } + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAnyUniqueAliases( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyUniqueAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(value); + return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case AnyUniqueAliases_M: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyUniqueAliases_TS: { + value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast(u.value)); + break; + } + case AnyUniqueAliases_M2: { + value = new MyGame::Example2::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyUniqueAliasesUnion::Reset() { + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = AnyUniqueAliases_NONE; +} + +inline bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) { + switch (type) { + case AnyAmbiguousAliases_NONE: { + return true; + } + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAnyAmbiguousAliases( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyAmbiguousAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case AnyAmbiguousAliases_M1: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyAmbiguousAliases_M2: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyAmbiguousAliases_M3: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyAmbiguousAliasesUnion::Reset() { + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = AnyAmbiguousAliases_NONE; +} + +inline const flatbuffers::TypeTable *ColorTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_UCHAR, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable + }; + static const int64_t values[] = { 1, 2, 8 }; + static const char * const names[] = { + "Red", + "Green", + "Blue" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *RaceTypeTable() { + 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 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::RaceTypeTable + }; + static const int64_t values[] = { -1, 0, 1, 2 }; + static const char * const names[] = { + "None", + "Human", + "Dwarf", + "Elf" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *LongEnumTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_ULONG, 0, 0 }, + { flatbuffers::ET_ULONG, 0, 0 }, + { flatbuffers::ET_ULONG, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::LongEnumTypeTable + }; + static const int64_t values[] = { 2ULL, 4ULL, 1099511627776ULL }; + static const char * const names[] = { + "LongOne", + "LongTwo", + "LongBig" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 2 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable, + MyGame::Example::TestSimpleTableWithEnumTypeTable, + MyGame::Example2::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "Monster", + "TestSimpleTableWithEnum", + "MyGame_Example2_Monster" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 2 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable, + MyGame::Example::TestSimpleTableWithEnumTypeTable, + MyGame::Example2::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "M", + "TS", + "M2" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "M1", + "M2", + "M3" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +} // namespace Example + +inline const flatbuffers::TypeTable *InParentNamespaceTypeTable() { + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr + }; + return &tt; +} + +namespace Example2 { + +inline const flatbuffers::TypeTable *MonsterTypeTable() { + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr + }; + return &tt; +} + +} // namespace Example2 + +namespace Example { + +inline const flatbuffers::TypeTable *TestTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_CHAR, 0, -1 } + }; + static const int64_t values[] = { 0, 2, 4 }; + static const char * const names[] = { + "a", + "b" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UCHAR, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable + }; + static const char * const names[] = { + "color" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *Vec3TypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_DOUBLE, 0, -1 }, + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable, + MyGame::Example::TestTypeTable + }; + static const int64_t values[] = { 0, 4, 8, 16, 24, 26, 32 }; + static const char * const names[] = { + "x", + "y", + "z", + "test1", + "test2", + "test3" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 6, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AbilityTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8 }; + static const char * const names[] = { + "id", + "distance" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StructOfStructsTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::AbilityTypeTable, + MyGame::Example::TestTypeTable + }; + static const int64_t values[] = { 0, 8, 12, 20 }; + static const char * const names[] = { + "a", + "b", + "c" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::StructOfStructsTypeTable + }; + static const int64_t values[] = { 0, 20 }; + static const char * const names[] = { + "a" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 1, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StatTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_STRING, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_USHORT, 0, -1 } + }; + static const char * const names[] = { + "id", + "val", + "count" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *ReferrableTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_ULONG, 0, -1 } + }; + static const char * const names[] = { + "id" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *MonsterTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_STRING, 0, -1 }, + { flatbuffers::ET_BOOL, 0, -1 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_UCHAR, 0, 1 }, + { flatbuffers::ET_UTYPE, 0, 2 }, + { flatbuffers::ET_SEQUENCE, 0, 2 }, + { flatbuffers::ET_SEQUENCE, 1, 3 }, + { flatbuffers::ET_STRING, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 4 }, + { flatbuffers::ET_SEQUENCE, 0, 4 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 5 }, + { flatbuffers::ET_BOOL, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_BOOL, 1, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_STRING, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 6 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 3 }, + { flatbuffers::ET_LONG, 1, -1 }, + { flatbuffers::ET_DOUBLE, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 7 }, + { flatbuffers::ET_SEQUENCE, 1, 8 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 8 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_UTYPE, 0, 9 }, + { flatbuffers::ET_SEQUENCE, 0, 9 }, + { flatbuffers::ET_UTYPE, 0, 10 }, + { flatbuffers::ET_SEQUENCE, 0, 10 }, + { flatbuffers::ET_UCHAR, 1, 1 }, + { flatbuffers::ET_CHAR, 0, 11 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 5 }, + { flatbuffers::ET_SEQUENCE, 0, 3 }, + { flatbuffers::ET_ULONG, 0, 12 }, + { flatbuffers::ET_ULONG, 0, 12 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::Vec3TypeTable, + MyGame::Example::ColorTypeTable, + MyGame::Example::AnyTypeTable, + MyGame::Example::TestTypeTable, + MyGame::Example::MonsterTypeTable, + MyGame::Example::StatTypeTable, + MyGame::Example::AbilityTypeTable, + MyGame::InParentNamespaceTypeTable, + MyGame::Example::ReferrableTypeTable, + MyGame::Example::AnyUniqueAliasesTypeTable, + MyGame::Example::AnyAmbiguousAliasesTypeTable, + MyGame::Example::RaceTypeTable, + MyGame::Example::LongEnumTypeTable + }; + static const char * const names[] = { + "pos", + "mana", + "hp", + "name", + "friendly", + "inventory", + "color", + "test_type", + "test", + "test4", + "testarrayofstring", + "testarrayoftables", + "enemy", + "testnestedflatbuffer", + "testempty", + "testbool", + "testhashs32_fnv1", + "testhashu32_fnv1", + "testhashs64_fnv1", + "testhashu64_fnv1", + "testhashs32_fnv1a", + "testhashu32_fnv1a", + "testhashs64_fnv1a", + "testhashu64_fnv1a", + "testarrayofbools", + "testf", + "testf2", + "testf3", + "testarrayofstring2", + "testarrayofsortedstruct", + "flex", + "test5", + "vector_of_longs", + "vector_of_doubles", + "parent_namespace_test", + "vector_of_referrables", + "single_weak_reference", + "vector_of_weak_references", + "vector_of_strong_referrables", + "co_owning_reference", + "vector_of_co_owning_references", + "non_owning_reference", + "vector_of_non_owning_references", + "any_unique_type", + "any_unique", + "any_ambiguous_type", + "any_ambiguous", + "vector_of_enums", + "signed_enum", + "testrequirednestedflatbuffer", + "scalar_key_sorted_tables", + "native_inline", + "long_enum_non_enum_default", + "long_enum_normal_default" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *TypeAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_CHAR, 0, -1 }, + { flatbuffers::ET_UCHAR, 0, -1 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_USHORT, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_DOUBLE, 0, -1 }, + { flatbuffers::ET_CHAR, 1, -1 }, + { flatbuffers::ET_DOUBLE, 1, -1 } + }; + static const char * const names[] = { + "i8", + "u8", + "i16", + "u16", + "i32", + "u32", + "i64", + "u64", + "f32", + "f64", + "v8", + "vf64" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const MyGame::Example::Monster *GetMonster(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline Monster *GetMutableMonster(void *buf) { + return flatbuffers::GetMutableRoot(buf); +} + +inline MyGame::Example::Monster *GetMutableSizePrefixedMonster(void *buf) { + return flatbuffers::GetMutableSizePrefixedRoot(buf); +} + +inline const char *MonsterIdentifier() { + return "MONS"; +} + +inline bool MonsterBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, MonsterIdentifier()); +} + +inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, MonsterIdentifier(), true); +} + +inline bool VerifyMonsterBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(MonsterIdentifier()); +} + +inline bool VerifySizePrefixedMonsterBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(MonsterIdentifier()); +} + +inline const char *MonsterExtension() { + return "mon"; +} + +inline void FinishMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root, MonsterIdentifier()); +} + +inline void FinishSizePrefixedMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root, MonsterIdentifier()); +} + +inline flatbuffers::unique_ptr UnPackMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr(GetMonster(buf)->UnPack(res)); +} + +inline flatbuffers::unique_ptr UnPackSizePrefixedMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr(GetSizePrefixedMonster(buf)->UnPack(res)); +} + +} // namespace Example +} // namespace MyGame + +#endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ diff --git a/tests/monster_test_suffix/monster_test.grpc.fb.cc b/tests/monster_test_suffix/monster_test.grpc.fb.cc new file mode 100644 index 000000000..6680f4f7c --- /dev/null +++ b/tests/monster_test_suffix/monster_test.grpc.fb.cc @@ -0,0 +1,131 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: monster_test + +#include "monster_test_suffix.hpp" +#include "monster_test.grpc.fb.h" + +#include +#include +#include +#include +#include +#include +#include +#include +namespace MyGame { +namespace Example { + +static const char* MonsterStorage_method_names[] = { + "/MyGame.Example.MonsterStorage/Store", + "/MyGame.Example.MonsterStorage/Retrieve", + "/MyGame.Example.MonsterStorage/GetMaxHitPoint", + "/MyGame.Example.MonsterStorage/GetMinMaxHitPoints", +}; + +std::unique_ptr< MonsterStorage::Stub> MonsterStorage::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& /*options*/) { + std::unique_ptr< MonsterStorage::Stub> stub(new MonsterStorage::Stub(channel)); + return stub; +} + +MonsterStorage::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel) + : channel_(channel) , rpcmethod_Store_(MonsterStorage_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel) + , rpcmethod_Retrieve_(MonsterStorage_method_names[1], ::grpc::internal::RpcMethod::SERVER_STREAMING, channel) + , rpcmethod_GetMaxHitPoint_(MonsterStorage_method_names[2], ::grpc::internal::RpcMethod::CLIENT_STREAMING, channel) + , rpcmethod_GetMinMaxHitPoints_(MonsterStorage_method_names[3], ::grpc::internal::RpcMethod::BIDI_STREAMING, channel) + {} + +::grpc::Status MonsterStorage::Stub::Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) { + return ::grpc::internal::BlockingUnaryCall(channel_.get(), rpcmethod_Store_, context, request, response); +} + +::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, true); +} + +::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncResponseReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Store_, context, request, false); +} + +::grpc::ClientReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return ::grpc::internal::ClientReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_Retrieve_, context, request); +} + +::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, true, tag); +} + +::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_Retrieve_, context, request, false, nullptr); +} + +::grpc::ClientWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return ::grpc::internal::ClientWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_GetMaxHitPoint_, context, response); +} + +::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMaxHitPoint_, context, response, true, tag); +} + +::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncWriterFactory< flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMaxHitPoint_, context, response, false, nullptr); +} + +::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::GetMinMaxHitPointsRaw(::grpc::ClientContext* context) { + return ::grpc::internal::ClientReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), rpcmethod_GetMinMaxHitPoints_, context); +} + +::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMinMaxHitPoints_, context, true, tag); +} + +::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* MonsterStorage::Stub::PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return ::grpc::internal::ClientAsyncReaderWriterFactory< flatbuffers::grpc::Message, flatbuffers::grpc::Message>::Create(channel_.get(), cq, rpcmethod_GetMinMaxHitPoints_, context, false, nullptr); +} + +MonsterStorage::Service::Service() { + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[0], + ::grpc::internal::RpcMethod::NORMAL_RPC, + new ::grpc::internal::RpcMethodHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::Store), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[1], + ::grpc::internal::RpcMethod::SERVER_STREAMING, + new ::grpc::internal::ServerStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::Retrieve), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[2], + ::grpc::internal::RpcMethod::CLIENT_STREAMING, + new ::grpc::internal::ClientStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::GetMaxHitPoint), this))); + AddMethod(new ::grpc::internal::RpcServiceMethod( + MonsterStorage_method_names[3], + ::grpc::internal::RpcMethod::BIDI_STREAMING, + new ::grpc::internal::BidiStreamingHandler< MonsterStorage::Service, flatbuffers::grpc::Message, flatbuffers::grpc::Message>( + std::mem_fn(&MonsterStorage::Service::GetMinMaxHitPoints), this))); +} + +MonsterStorage::Service::~Service() { +} + +::grpc::Status MonsterStorage::Service::Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* /*response*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + +::grpc::Status MonsterStorage::Service::GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) { + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); +} + + +} // namespace MyGame +} // namespace Example + diff --git a/tests/monster_test_suffix/monster_test.grpc.fb.h b/tests/monster_test_suffix/monster_test.grpc.fb.h new file mode 100644 index 000000000..b5ea5569d --- /dev/null +++ b/tests/monster_test_suffix/monster_test.grpc.fb.h @@ -0,0 +1,350 @@ +// Generated by the gRPC C++ plugin. +// If you make any local change, they will be lost. +// source: monster_test +#ifndef GRPC_monster_5ftest__INCLUDED +#define GRPC_monster_5ftest__INCLUDED + +#include "monster_test_suffix.hpp" +#include "flatbuffers/grpc.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace grpc { +class CompletionQueue; +class Channel; +class ServerCompletionQueue; +class ServerContext; +} // namespace grpc + +namespace MyGame { +namespace Example { + +class MonsterStorage final { + public: + static constexpr char const* service_full_name() { + return "MyGame.Example.MonsterStorage"; + } + class StubInterface { + public: + virtual ~StubInterface() {} + virtual ::grpc::Status Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) = 0; + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return std::unique_ptr< ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>> GetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return std::unique_ptr< ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>>(GetMaxHitPointRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>> AsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>>(AsyncGetMaxHitPointRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>> PrepareAsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>>(PrepareAsyncGetMaxHitPointRaw(context, response, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> GetMinMaxHitPoints(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(GetMinMaxHitPointsRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> AsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(AsyncGetMinMaxHitPointsRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> PrepareAsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(PrepareAsyncGetMinMaxHitPointsRaw(context, cq)); + } + private: + virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientAsyncResponseReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderInterface< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) = 0; + virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderInterface< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientWriterInterface< flatbuffers::grpc::Message>* GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) = 0; + virtual ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>* AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncWriterInterface< flatbuffers::grpc::Message>* PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) = 0; + virtual ::grpc::ClientReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* GetMinMaxHitPointsRaw(::grpc::ClientContext* context) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) = 0; + virtual ::grpc::ClientAsyncReaderWriterInterface< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) = 0; + }; + class Stub final : public StubInterface { + public: + Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel); + ::grpc::Status Store(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, flatbuffers::grpc::Message* response) override; + std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> AsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(AsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>> PrepareAsyncStore(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>>(PrepareAsyncStoreRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>> Retrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) { + return std::unique_ptr< ::grpc::ClientReader< flatbuffers::grpc::Message>>(RetrieveRaw(context, request)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> AsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(AsyncRetrieveRaw(context, request, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>> PrepareAsyncRetrieve(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>>(PrepareAsyncRetrieveRaw(context, request, cq)); + } + std::unique_ptr< ::grpc::ClientWriter< flatbuffers::grpc::Message>> GetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) { + return std::unique_ptr< ::grpc::ClientWriter< flatbuffers::grpc::Message>>(GetMaxHitPointRaw(context, response)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>> AsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>>(AsyncGetMaxHitPointRaw(context, response, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>> PrepareAsyncGetMaxHitPoint(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>>(PrepareAsyncGetMaxHitPointRaw(context, response, cq)); + } + std::unique_ptr< ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> GetMinMaxHitPoints(::grpc::ClientContext* context) { + return std::unique_ptr< ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(GetMinMaxHitPointsRaw(context)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> AsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(AsyncGetMinMaxHitPointsRaw(context, cq, tag)); + } + std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>> PrepareAsyncGetMinMaxHitPoints(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) { + return std::unique_ptr< ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>>(PrepareAsyncGetMinMaxHitPointsRaw(context, cq)); + } + + private: + std::shared_ptr< ::grpc::ChannelInterface> channel_; + ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* AsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientAsyncResponseReader< flatbuffers::grpc::Message>* PrepareAsyncStoreRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReader< flatbuffers::grpc::Message>* RetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request) override; + ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* AsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReader< flatbuffers::grpc::Message>* PrepareAsyncRetrieveRaw(::grpc::ClientContext* context, const flatbuffers::grpc::Message& request, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientWriter< flatbuffers::grpc::Message>* GetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response) override; + ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* AsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncWriter< flatbuffers::grpc::Message>* PrepareAsyncGetMaxHitPointRaw(::grpc::ClientContext* context, flatbuffers::grpc::Message* response, ::grpc::CompletionQueue* cq) override; + ::grpc::ClientReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* GetMinMaxHitPointsRaw(::grpc::ClientContext* context) override; + ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* AsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq, void* tag) override; + ::grpc::ClientAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* PrepareAsyncGetMinMaxHitPointsRaw(::grpc::ClientContext* context, ::grpc::CompletionQueue* cq) override; + const ::grpc::internal::RpcMethod rpcmethod_Store_; + const ::grpc::internal::RpcMethod rpcmethod_Retrieve_; + const ::grpc::internal::RpcMethod rpcmethod_GetMaxHitPoint_; + const ::grpc::internal::RpcMethod rpcmethod_GetMinMaxHitPoints_; + }; + static std::unique_ptr NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions()); + + class Service : public ::grpc::Service { + public: + Service(); + virtual ~Service(); + virtual ::grpc::Status Store(::grpc::ServerContext* context, const flatbuffers::grpc::Message* request, flatbuffers::grpc::Message* response); + virtual ::grpc::Status Retrieve(::grpc::ServerContext* context, const flatbuffers::grpc::Message* request, ::grpc::ServerWriter< flatbuffers::grpc::Message>* writer); + virtual ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* context, ::grpc::ServerReader< flatbuffers::grpc::Message>* reader, flatbuffers::grpc::Message* response); + virtual ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* context, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* stream); + }; + template + class WithAsyncMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_Store() { + ::grpc::Service::MarkMethodAsync(0); + } + ~WithAsyncMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestStore(::grpc::ServerContext* context, flatbuffers::grpc::Message* request, ::grpc::ServerAsyncResponseWriter< flatbuffers::grpc::Message>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_Retrieve() { + ::grpc::Service::MarkMethodAsync(1); + } + ~WithAsyncMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestRetrieve(::grpc::ServerContext* context, flatbuffers::grpc::Message* request, ::grpc::ServerAsyncWriter< flatbuffers::grpc::Message>* writer, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncServerStreaming(1, context, request, writer, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetMaxHitPoint : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_GetMaxHitPoint() { + ::grpc::Service::MarkMethodAsync(2); + } + ~WithAsyncMethod_GetMaxHitPoint() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* response) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetMaxHitPoint(::grpc::ServerContext* context, ::grpc::ServerAsyncReader< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* reader, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncClientStreaming(2, context, reader, new_call_cq, notification_cq, tag); + } + }; + template + class WithAsyncMethod_GetMinMaxHitPoints : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithAsyncMethod_GetMinMaxHitPoints() { + ::grpc::Service::MarkMethodAsync(3); + } + ~WithAsyncMethod_GetMinMaxHitPoints() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + void RequestGetMinMaxHitPoints(::grpc::ServerContext* context, ::grpc::ServerAsyncReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* stream, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) { + ::grpc::Service::RequestAsyncBidiStreaming(3, context, stream, new_call_cq, notification_cq, tag); + } + }; + typedef WithAsyncMethod_Store< WithAsyncMethod_Retrieve< WithAsyncMethod_GetMaxHitPoint< WithAsyncMethod_GetMinMaxHitPoints< Service > > > > AsyncService; + template + class WithGenericMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_Store() { + ::grpc::Service::MarkMethodGeneric(0); + } + ~WithGenericMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_Retrieve() { + ::grpc::Service::MarkMethodGeneric(1); + } + ~WithGenericMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetMaxHitPoint : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_GetMaxHitPoint() { + ::grpc::Service::MarkMethodGeneric(2); + } + ~WithGenericMethod_GetMaxHitPoint() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMaxHitPoint(::grpc::ServerContext* /*context*/, ::grpc::ServerReader< flatbuffers::grpc::Message>* /*reader*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithGenericMethod_GetMinMaxHitPoints : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithGenericMethod_GetMinMaxHitPoints() { + ::grpc::Service::MarkMethodGeneric(3); + } + ~WithGenericMethod_GetMinMaxHitPoints() override { + BaseClassMustBeDerivedFromService(this); + } + // disable synchronous version of this method + ::grpc::Status GetMinMaxHitPoints(::grpc::ServerContext* /*context*/, ::grpc::ServerReaderWriter< flatbuffers::grpc::Message, flatbuffers::grpc::Message>* /*stream*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + }; + template + class WithStreamedUnaryMethod_Store : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) {} + public: + WithStreamedUnaryMethod_Store() { + ::grpc::Service::MarkMethodStreamed(0, + new ::grpc::internal::StreamedUnaryHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithStreamedUnaryMethod_Store::StreamedStore, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithStreamedUnaryMethod_Store() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Store(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, flatbuffers::grpc::Message* /*response*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with streamed unary + virtual ::grpc::Status StreamedStore(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< flatbuffers::grpc::Message,flatbuffers::grpc::Message>* server_unary_streamer) = 0; + }; + typedef WithStreamedUnaryMethod_Store< Service > StreamedUnaryService; + template + class WithSplitStreamingMethod_Retrieve : public BaseClass { + private: + void BaseClassMustBeDerivedFromService(const Service */*service*/) { } + public: + WithSplitStreamingMethod_Retrieve() { + ::grpc::Service::MarkMethodStreamed(1, + new ::grpc::internal::SplitServerStreamingHandler< flatbuffers::grpc::Message, flatbuffers::grpc::Message>(std::bind(&WithSplitStreamingMethod_Retrieve::StreamedRetrieve, this, std::placeholders::_1, std::placeholders::_2))); + } + ~WithSplitStreamingMethod_Retrieve() override { + BaseClassMustBeDerivedFromService(this); + } + // disable regular version of this method + ::grpc::Status Retrieve(::grpc::ServerContext* /*context*/, const flatbuffers::grpc::Message* /*request*/, ::grpc::ServerWriter< flatbuffers::grpc::Message>* /*writer*/) final override { + abort(); + return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, ""); + } + // replace default version of method with split streamed + virtual ::grpc::Status StreamedRetrieve(::grpc::ServerContext* context, ::grpc::ServerSplitStreamer< flatbuffers::grpc::Message,flatbuffers::grpc::Message>* server_split_streamer) = 0; + }; + typedef WithSplitStreamingMethod_Retrieve< Service > SplitStreamedService; + typedef WithStreamedUnaryMethod_Store< WithSplitStreamingMethod_Retrieve< Service > > StreamedService; +}; + +} // namespace Example +} // namespace MyGame + + +#endif // GRPC_monster_5ftest__INCLUDED diff --git a/tests/monster_test_suffix/monster_test_suffix.hpp b/tests/monster_test_suffix/monster_test_suffix.hpp new file mode 100644 index 000000000..5e2308c7b --- /dev/null +++ b/tests/monster_test_suffix/monster_test_suffix.hpp @@ -0,0 +1,4041 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ +#define FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_ + +#include "flatbuffers/flatbuffers.h" +#include "flatbuffers/flexbuffers.h" +#include "flatbuffers/flex_flat_util.h" + +// Ensure the included flatbuffers.h is the same version as when this file was +// generated, otherwise it may not be compatible. +static_assert(FLATBUFFERS_VERSION_MAJOR == 2 && + FLATBUFFERS_VERSION_MINOR == 0 && + FLATBUFFERS_VERSION_REVISION == 6, + "Non-compatible flatbuffers version included"); + +namespace MyGame { + +struct InParentNamespace; +struct InParentNamespaceBuilder; +struct InParentNamespaceT; + +namespace Example2 { + +struct Monster; +struct MonsterBuilder; +struct MonsterT; + +} // namespace Example2 + +namespace Example { + +struct Test; + +struct TestSimpleTableWithEnum; +struct TestSimpleTableWithEnumBuilder; +struct TestSimpleTableWithEnumT; + +struct Vec3; + +struct Ability; + +struct StructOfStructs; + +struct StructOfStructsOfStructs; + +struct Stat; +struct StatBuilder; +struct StatT; + +struct Referrable; +struct ReferrableBuilder; +struct ReferrableT; + +struct Monster; +struct MonsterBuilder; +struct MonsterT; + +struct TypeAliases; +struct TypeAliasesBuilder; +struct TypeAliasesT; + +} // namespace Example + +bool operator==(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs); +bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs); +namespace Example2 { + +bool operator==(const MonsterT &lhs, const MonsterT &rhs); +bool operator!=(const MonsterT &lhs, const MonsterT &rhs); +} // namespace Example2 + +namespace Example { + +bool operator==(const Test &lhs, const Test &rhs); +bool operator!=(const Test &lhs, const Test &rhs); +bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs); +bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs); +bool operator==(const Vec3 &lhs, const Vec3 &rhs); +bool operator!=(const Vec3 &lhs, const Vec3 &rhs); +bool operator==(const Ability &lhs, const Ability &rhs); +bool operator!=(const Ability &lhs, const Ability &rhs); +bool operator==(const StructOfStructs &lhs, const StructOfStructs &rhs); +bool operator!=(const StructOfStructs &lhs, const StructOfStructs &rhs); +bool operator==(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs); +bool operator!=(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs); +bool operator==(const StatT &lhs, const StatT &rhs); +bool operator!=(const StatT &lhs, const StatT &rhs); +bool operator==(const ReferrableT &lhs, const ReferrableT &rhs); +bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs); +bool operator==(const MonsterT &lhs, const MonsterT &rhs); +bool operator!=(const MonsterT &lhs, const MonsterT &rhs); +bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs); +bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs); + +} // namespace Example + +inline const flatbuffers::TypeTable *InParentNamespaceTypeTable(); + +namespace Example2 { + +inline const flatbuffers::TypeTable *MonsterTypeTable(); + +} // namespace Example2 + +namespace Example { + +inline const flatbuffers::TypeTable *TestTypeTable(); + +inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable(); + +inline const flatbuffers::TypeTable *Vec3TypeTable(); + +inline const flatbuffers::TypeTable *AbilityTypeTable(); + +inline const flatbuffers::TypeTable *StructOfStructsTypeTable(); + +inline const flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable(); + +inline const flatbuffers::TypeTable *StatTypeTable(); + +inline const flatbuffers::TypeTable *ReferrableTypeTable(); + +inline const flatbuffers::TypeTable *MonsterTypeTable(); + +inline const flatbuffers::TypeTable *TypeAliasesTypeTable(); + +/// Composite components of Monster color. +enum Color : uint8_t { + Color_Red = 1, + /// \brief color Green + /// Green is bit_flag with value (1u << 1) + Color_Green = 2, + /// \brief color Blue (1u << 3) + Color_Blue = 8, + Color_NONE = 0, + Color_ANY = 11 +}; + +inline const Color (&EnumValuesColor())[3] { + static const Color values[] = { + Color_Red, + Color_Green, + Color_Blue + }; + return values; +} + +inline const char * const *EnumNamesColor() { + static const char * const names[9] = { + "Red", + "Green", + "", + "", + "", + "", + "", + "Blue", + nullptr + }; + return names; +} + +inline const char *EnumNameColor(Color e) { + if (flatbuffers::IsOutRange(e, Color_Red, Color_Blue)) return ""; + const size_t index = static_cast(e) - static_cast(Color_Red); + return EnumNamesColor()[index]; +} + +enum Race : int8_t { + Race_None = -1, + Race_Human = 0, + Race_Dwarf = 1, + Race_Elf = 2, + Race_MIN = Race_None, + Race_MAX = Race_Elf +}; + +inline const Race (&EnumValuesRace())[4] { + static const Race values[] = { + Race_None, + Race_Human, + Race_Dwarf, + Race_Elf + }; + return values; +} + +inline const char * const *EnumNamesRace() { + static const char * const names[5] = { + "None", + "Human", + "Dwarf", + "Elf", + nullptr + }; + return names; +} + +inline const char *EnumNameRace(Race e) { + if (flatbuffers::IsOutRange(e, Race_None, Race_Elf)) return ""; + const size_t index = static_cast(e) - static_cast(Race_None); + return EnumNamesRace()[index]; +} + +enum LongEnum : uint64_t { + LongEnum_LongOne = 2ULL, + LongEnum_LongTwo = 4ULL, + LongEnum_LongBig = 1099511627776ULL, + LongEnum_NONE = 0, + LongEnum_ANY = 1099511627782ULL +}; + +inline const LongEnum (&EnumValuesLongEnum())[3] { + static const LongEnum values[] = { + LongEnum_LongOne, + LongEnum_LongTwo, + LongEnum_LongBig + }; + return values; +} + +inline const char *EnumNameLongEnum(LongEnum e) { + switch (e) { + case LongEnum_LongOne: return "LongOne"; + case LongEnum_LongTwo: return "LongTwo"; + case LongEnum_LongBig: return "LongBig"; + default: return ""; + } +} + +enum Any : uint8_t { + Any_NONE = 0, + Any_Monster = 1, + Any_TestSimpleTableWithEnum = 2, + Any_MyGame_Example2_Monster = 3, + Any_MIN = Any_NONE, + Any_MAX = Any_MyGame_Example2_Monster +}; + +inline const Any (&EnumValuesAny())[4] { + static const Any values[] = { + Any_NONE, + Any_Monster, + Any_TestSimpleTableWithEnum, + Any_MyGame_Example2_Monster + }; + return values; +} + +inline const char * const *EnumNamesAny() { + static const char * const names[5] = { + "NONE", + "Monster", + "TestSimpleTableWithEnum", + "MyGame_Example2_Monster", + nullptr + }; + return names; +} + +inline const char *EnumNameAny(Any e) { + if (flatbuffers::IsOutRange(e, Any_NONE, Any_MyGame_Example2_Monster)) return ""; + const size_t index = static_cast(e); + return EnumNamesAny()[index]; +} + +template struct AnyTraits { + static const Any enum_value = Any_NONE; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_Monster; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_TestSimpleTableWithEnum; +}; + +template<> struct AnyTraits { + static const Any enum_value = Any_MyGame_Example2_Monster; +}; + +template struct AnyUnionTraits { + static const Any enum_value = Any_NONE; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_Monster; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_TestSimpleTableWithEnum; +}; + +template<> struct AnyUnionTraits { + static const Any enum_value = Any_MyGame_Example2_Monster; +}; + +struct AnyUnion { + Any type; + void *value; + + AnyUnion() : type(Any_NONE), value(nullptr) {} + AnyUnion(AnyUnion&& u) FLATBUFFERS_NOEXCEPT : + type(Any_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyUnion(const AnyUnion &); + AnyUnion &operator=(const AnyUnion &u) + { AnyUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyUnion &operator=(AnyUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = AnyUnionTraits::enum_value; + if (type != Any_NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsMonster() { + return type == Any_Monster ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsMonster() const { + return type == Any_Monster ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() { + return type == Any_TestSimpleTableWithEnum ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnumT *AsTestSimpleTableWithEnum() const { + return type == Any_TestSimpleTableWithEnum ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() { + return type == Any_MyGame_Example2_Monster ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example2::MonsterT *AsMyGame_Example2_Monster() const { + return type == Any_MyGame_Example2_Monster ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyUnion &lhs, const AnyUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case Any_NONE: { + return true; + } + case Any_Monster: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case Any_TestSimpleTableWithEnum: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case Any_MyGame_Example2_Monster: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyUnion &lhs, const AnyUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type); +bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum AnyUniqueAliases : uint8_t { + AnyUniqueAliases_NONE = 0, + AnyUniqueAliases_M = 1, + AnyUniqueAliases_TS = 2, + AnyUniqueAliases_M2 = 3, + AnyUniqueAliases_MIN = AnyUniqueAliases_NONE, + AnyUniqueAliases_MAX = AnyUniqueAliases_M2 +}; + +inline const AnyUniqueAliases (&EnumValuesAnyUniqueAliases())[4] { + static const AnyUniqueAliases values[] = { + AnyUniqueAliases_NONE, + AnyUniqueAliases_M, + AnyUniqueAliases_TS, + AnyUniqueAliases_M2 + }; + return values; +} + +inline const char * const *EnumNamesAnyUniqueAliases() { + static const char * const names[5] = { + "NONE", + "M", + "TS", + "M2", + nullptr + }; + return names; +} + +inline const char *EnumNameAnyUniqueAliases(AnyUniqueAliases e) { + if (flatbuffers::IsOutRange(e, AnyUniqueAliases_NONE, AnyUniqueAliases_M2)) return ""; + const size_t index = static_cast(e); + return EnumNamesAnyUniqueAliases()[index]; +} + +template struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS; +}; + +template<> struct AnyUniqueAliasesTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2; +}; + +template struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_NONE; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_TS; +}; + +template<> struct AnyUniqueAliasesUnionTraits { + static const AnyUniqueAliases enum_value = AnyUniqueAliases_M2; +}; + +struct AnyUniqueAliasesUnion { + AnyUniqueAliases type; + void *value; + + AnyUniqueAliasesUnion() : type(AnyUniqueAliases_NONE), value(nullptr) {} + AnyUniqueAliasesUnion(AnyUniqueAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(AnyUniqueAliases_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &); + AnyUniqueAliasesUnion &operator=(const AnyUniqueAliasesUnion &u) + { AnyUniqueAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyUniqueAliasesUnion &operator=(AnyUniqueAliasesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyUniqueAliasesUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = AnyUniqueAliasesUnionTraits::enum_value; + if (type != AnyUniqueAliases_NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsM() { + return type == AnyUniqueAliases_M ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM() const { + return type == AnyUniqueAliases_M ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::TestSimpleTableWithEnumT *AsTS() { + return type == AnyUniqueAliases_TS ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnumT *AsTS() const { + return type == AnyUniqueAliases_TS ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example2::MonsterT *AsM2() { + return type == AnyUniqueAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example2::MonsterT *AsM2() const { + return type == AnyUniqueAliases_M2 ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case AnyUniqueAliases_NONE: { + return true; + } + case AnyUniqueAliases_M: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyUniqueAliases_TS: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyUniqueAliases_M2: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyUniqueAliasesUnion &lhs, const AnyUniqueAliasesUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type); +bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum AnyAmbiguousAliases : uint8_t { + AnyAmbiguousAliases_NONE = 0, + AnyAmbiguousAliases_M1 = 1, + AnyAmbiguousAliases_M2 = 2, + AnyAmbiguousAliases_M3 = 3, + AnyAmbiguousAliases_MIN = AnyAmbiguousAliases_NONE, + AnyAmbiguousAliases_MAX = AnyAmbiguousAliases_M3 +}; + +inline const AnyAmbiguousAliases (&EnumValuesAnyAmbiguousAliases())[4] { + static const AnyAmbiguousAliases values[] = { + AnyAmbiguousAliases_NONE, + AnyAmbiguousAliases_M1, + AnyAmbiguousAliases_M2, + AnyAmbiguousAliases_M3 + }; + return values; +} + +inline const char * const *EnumNamesAnyAmbiguousAliases() { + static const char * const names[5] = { + "NONE", + "M1", + "M2", + "M3", + nullptr + }; + return names; +} + +inline const char *EnumNameAnyAmbiguousAliases(AnyAmbiguousAliases e) { + if (flatbuffers::IsOutRange(e, AnyAmbiguousAliases_NONE, AnyAmbiguousAliases_M3)) return ""; + const size_t index = static_cast(e); + return EnumNamesAnyAmbiguousAliases()[index]; +} + +struct AnyAmbiguousAliasesUnion { + AnyAmbiguousAliases type; + void *value; + + AnyAmbiguousAliasesUnion() : type(AnyAmbiguousAliases_NONE), value(nullptr) {} + AnyAmbiguousAliasesUnion(AnyAmbiguousAliasesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(AnyAmbiguousAliases_NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &); + AnyAmbiguousAliasesUnion &operator=(const AnyAmbiguousAliasesUnion &u) + { AnyAmbiguousAliasesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + AnyAmbiguousAliasesUnion &operator=(AnyAmbiguousAliasesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~AnyAmbiguousAliasesUnion() { Reset(); } + + void Reset(); + + static void *UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + MyGame::Example::MonsterT *AsM1() { + return type == AnyAmbiguousAliases_M1 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM1() const { + return type == AnyAmbiguousAliases_M1 ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::MonsterT *AsM2() { + return type == AnyAmbiguousAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM2() const { + return type == AnyAmbiguousAliases_M2 ? + reinterpret_cast(value) : nullptr; + } + MyGame::Example::MonsterT *AsM3() { + return type == AnyAmbiguousAliases_M3 ? + reinterpret_cast(value) : nullptr; + } + const MyGame::Example::MonsterT *AsM3() const { + return type == AnyAmbiguousAliases_M3 ? + reinterpret_cast(value) : nullptr; + } +}; + + +inline bool operator==(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) { + if (lhs.type != rhs.type) return false; + switch (lhs.type) { + case AnyAmbiguousAliases_NONE: { + return true; + } + case AnyAmbiguousAliases_M1: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyAmbiguousAliases_M2: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + case AnyAmbiguousAliases_M3: { + return *(reinterpret_cast(lhs.value)) == + *(reinterpret_cast(rhs.value)); + } + default: { + return false; + } + } +} + +inline bool operator!=(const AnyAmbiguousAliasesUnion &lhs, const AnyAmbiguousAliasesUnion &rhs) { + return !(lhs == rhs); +} + +bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type); +bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) Test FLATBUFFERS_FINAL_CLASS { + private: + int16_t a_; + int8_t b_; + int8_t padding0__; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TestTypeTable(); + } + Test() + : a_(0), + b_(0), + padding0__(0) { + (void)padding0__; + } + Test(int16_t _a, int8_t _b) + : a_(flatbuffers::EndianScalar(_a)), + b_(flatbuffers::EndianScalar(_b)), + padding0__(0) { + (void)padding0__; + } + int16_t a() const { + return flatbuffers::EndianScalar(a_); + } + void mutate_a(int16_t _a) { + flatbuffers::WriteScalar(&a_, _a); + } + int8_t b() const { + return flatbuffers::EndianScalar(b_); + } + void mutate_b(int8_t _b) { + flatbuffers::WriteScalar(&b_, _b); + } +}; +FLATBUFFERS_STRUCT_END(Test, 4); + +inline bool operator==(const Test &lhs, const Test &rhs) { + return + (lhs.a() == rhs.a()) && + (lhs.b() == rhs.b()); +} + +inline bool operator!=(const Test &lhs, const Test &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Vec3 FLATBUFFERS_FINAL_CLASS { + private: + float x_; + float y_; + float z_; + int32_t padding0__; + double test1_; + uint8_t test2_; + int8_t padding1__; + MyGame::Example::Test test3_; + int16_t padding2__; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return Vec3TypeTable(); + } + Vec3() + : x_(0), + y_(0), + z_(0), + padding0__(0), + test1_(0), + test2_(0), + padding1__(0), + test3_(), + padding2__(0) { + (void)padding0__; + (void)padding1__; + (void)padding2__; + } + Vec3(float _x, float _y, float _z, double _test1, MyGame::Example::Color _test2, const MyGame::Example::Test &_test3) + : x_(flatbuffers::EndianScalar(_x)), + y_(flatbuffers::EndianScalar(_y)), + z_(flatbuffers::EndianScalar(_z)), + padding0__(0), + test1_(flatbuffers::EndianScalar(_test1)), + test2_(flatbuffers::EndianScalar(static_cast(_test2))), + padding1__(0), + test3_(_test3), + padding2__(0) { + (void)padding0__; + (void)padding1__; + (void)padding2__; + } + float x() const { + return flatbuffers::EndianScalar(x_); + } + void mutate_x(float _x) { + flatbuffers::WriteScalar(&x_, _x); + } + float y() const { + return flatbuffers::EndianScalar(y_); + } + void mutate_y(float _y) { + flatbuffers::WriteScalar(&y_, _y); + } + float z() const { + return flatbuffers::EndianScalar(z_); + } + void mutate_z(float _z) { + flatbuffers::WriteScalar(&z_, _z); + } + double test1() const { + return flatbuffers::EndianScalar(test1_); + } + void mutate_test1(double _test1) { + flatbuffers::WriteScalar(&test1_, _test1); + } + MyGame::Example::Color test2() const { + return static_cast(flatbuffers::EndianScalar(test2_)); + } + void mutate_test2(MyGame::Example::Color _test2) { + flatbuffers::WriteScalar(&test2_, static_cast(_test2)); + } + const MyGame::Example::Test &test3() const { + return test3_; + } + MyGame::Example::Test &mutable_test3() { + return test3_; + } +}; +FLATBUFFERS_STRUCT_END(Vec3, 32); + +inline bool operator==(const Vec3 &lhs, const Vec3 &rhs) { + return + (lhs.x() == rhs.x()) && + (lhs.y() == rhs.y()) && + (lhs.z() == rhs.z()) && + (lhs.test1() == rhs.test1()) && + (lhs.test2() == rhs.test2()) && + (lhs.test3() == rhs.test3()); +} + +inline bool operator!=(const Vec3 &lhs, const Vec3 &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Ability FLATBUFFERS_FINAL_CLASS { + private: + uint32_t id_; + uint32_t distance_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return AbilityTypeTable(); + } + Ability() + : id_(0), + distance_(0) { + } + Ability(uint32_t _id, uint32_t _distance) + : id_(flatbuffers::EndianScalar(_id)), + distance_(flatbuffers::EndianScalar(_distance)) { + } + uint32_t id() const { + return flatbuffers::EndianScalar(id_); + } + void mutate_id(uint32_t _id) { + flatbuffers::WriteScalar(&id_, _id); + } + bool KeyCompareLessThan(const Ability *o) const { + return id() < o->id(); + } + int KeyCompareWithValue(uint32_t _id) const { + return static_cast(id() > _id) - static_cast(id() < _id); + } + uint32_t distance() const { + return flatbuffers::EndianScalar(distance_); + } + void mutate_distance(uint32_t _distance) { + flatbuffers::WriteScalar(&distance_, _distance); + } +}; +FLATBUFFERS_STRUCT_END(Ability, 8); + +inline bool operator==(const Ability &lhs, const Ability &rhs) { + return + (lhs.id() == rhs.id()) && + (lhs.distance() == rhs.distance()); +} + +inline bool operator!=(const Ability &lhs, const Ability &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructs FLATBUFFERS_FINAL_CLASS { + private: + MyGame::Example::Ability a_; + MyGame::Example::Test b_; + MyGame::Example::Ability c_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StructOfStructsTypeTable(); + } + StructOfStructs() + : a_(), + b_(), + c_() { + } + StructOfStructs(const MyGame::Example::Ability &_a, const MyGame::Example::Test &_b, const MyGame::Example::Ability &_c) + : a_(_a), + b_(_b), + c_(_c) { + } + const MyGame::Example::Ability &a() const { + return a_; + } + MyGame::Example::Ability &mutable_a() { + return a_; + } + const MyGame::Example::Test &b() const { + return b_; + } + MyGame::Example::Test &mutable_b() { + return b_; + } + const MyGame::Example::Ability &c() const { + return c_; + } + MyGame::Example::Ability &mutable_c() { + return c_; + } +}; +FLATBUFFERS_STRUCT_END(StructOfStructs, 20); + +inline bool operator==(const StructOfStructs &lhs, const StructOfStructs &rhs) { + return + (lhs.a() == rhs.a()) && + (lhs.b() == rhs.b()) && + (lhs.c() == rhs.c()); +} + +inline bool operator!=(const StructOfStructs &lhs, const StructOfStructs &rhs) { + return !(lhs == rhs); +} + + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) StructOfStructsOfStructs FLATBUFFERS_FINAL_CLASS { + private: + MyGame::Example::StructOfStructs a_; + + public: + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StructOfStructsOfStructsTypeTable(); + } + StructOfStructsOfStructs() + : a_() { + } + StructOfStructsOfStructs(const MyGame::Example::StructOfStructs &_a) + : a_(_a) { + } + const MyGame::Example::StructOfStructs &a() const { + return a_; + } + MyGame::Example::StructOfStructs &mutable_a() { + return a_; + } +}; +FLATBUFFERS_STRUCT_END(StructOfStructsOfStructs, 20); + +inline bool operator==(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs) { + return + (lhs.a() == rhs.a()); +} + +inline bool operator!=(const StructOfStructsOfStructs &lhs, const StructOfStructsOfStructs &rhs) { + return !(lhs == rhs); +} + + +} // namespace Example + +struct InParentNamespaceT : public flatbuffers::NativeTable { + typedef InParentNamespace TableType; +}; + +struct InParentNamespace FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InParentNamespaceT NativeTableType; + typedef InParentNamespaceBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return InParentNamespaceTypeTable(); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } + InParentNamespaceT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct InParentNamespaceBuilder { + typedef InParentNamespace Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit InParentNamespaceBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateInParentNamespace( + flatbuffers::FlatBufferBuilder &_fbb) { + InParentNamespaceBuilder builder_(_fbb); + return builder_.Finish(); +} + +flatbuffers::Offset CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +namespace Example2 { + +struct MonsterT : public flatbuffers::NativeTable { + typedef Monster TableType; +}; + +struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MonsterT NativeTableType; + typedef MonsterBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return MonsterTypeTable(); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } + MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct MonsterBuilder { + typedef Monster Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb) { + MonsterBuilder builder_(_fbb); + return builder_.Finish(); +} + +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +} // namespace Example2 + +namespace Example { + +struct TestSimpleTableWithEnumT : public flatbuffers::NativeTable { + typedef TestSimpleTableWithEnum TableType; + MyGame::Example::Color color = MyGame::Example::Color_Green; +}; + +struct TestSimpleTableWithEnum FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TestSimpleTableWithEnumT NativeTableType; + typedef TestSimpleTableWithEnumBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TestSimpleTableWithEnumTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_COLOR = 4 + }; + MyGame::Example::Color color() const { + return static_cast(GetField(VT_COLOR, 2)); + } + bool mutate_color(MyGame::Example::Color _color = static_cast(2)) { + return SetField(VT_COLOR, static_cast(_color), 2); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_COLOR, 1) && + verifier.EndTable(); + } + TestSimpleTableWithEnumT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TestSimpleTableWithEnumBuilder { + typedef TestSimpleTableWithEnum Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_color(MyGame::Example::Color color) { + fbb_.AddElement(TestSimpleTableWithEnum::VT_COLOR, static_cast(color), 2); + } + explicit TestSimpleTableWithEnumBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTestSimpleTableWithEnum( + flatbuffers::FlatBufferBuilder &_fbb, + MyGame::Example::Color color = MyGame::Example::Color_Green) { + TestSimpleTableWithEnumBuilder builder_(_fbb); + builder_.add_color(color); + return builder_.Finish(); +} + +flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct StatT : public flatbuffers::NativeTable { + typedef Stat TableType; + std::string id{}; + int64_t val = 0; + uint16_t count = 0; +}; + +struct Stat FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StatT NativeTableType; + typedef StatBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return StatTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4, + VT_VAL = 6, + VT_COUNT = 8 + }; + const flatbuffers::String *id() const { + return GetPointer(VT_ID); + } + flatbuffers::String *mutable_id() { + return GetPointer(VT_ID); + } + int64_t val() const { + return GetField(VT_VAL, 0); + } + bool mutate_val(int64_t _val = 0) { + return SetField(VT_VAL, _val, 0); + } + uint16_t count() const { + return GetField(VT_COUNT, 0); + } + bool mutate_count(uint16_t _count = 0) { + return SetField(VT_COUNT, _count, 0); + } + bool KeyCompareLessThan(const Stat *o) const { + return count() < o->count(); + } + int KeyCompareWithValue(uint16_t _count) const { + return static_cast(count() > _count) - static_cast(count() < _count); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ID) && + verifier.VerifyString(id()) && + VerifyField(verifier, VT_VAL, 8) && + VerifyField(verifier, VT_COUNT, 2) && + verifier.EndTable(); + } + StatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct StatBuilder { + typedef Stat Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(flatbuffers::Offset id) { + fbb_.AddOffset(Stat::VT_ID, id); + } + void add_val(int64_t val) { + fbb_.AddElement(Stat::VT_VAL, val, 0); + } + void add_count(uint16_t count) { + fbb_.AddElement(Stat::VT_COUNT, count, 0); + } + explicit StatBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateStat( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset id = 0, + int64_t val = 0, + uint16_t count = 0) { + StatBuilder builder_(_fbb); + builder_.add_val(val); + builder_.add_id(id); + builder_.add_count(count); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateStatDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *id = nullptr, + int64_t val = 0, + uint16_t count = 0) { + auto id__ = id ? _fbb.CreateString(id) : 0; + return MyGame::Example::CreateStat( + _fbb, + id__, + val, + count); +} + +flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReferrableT : public flatbuffers::NativeTable { + typedef Referrable TableType; + uint64_t id = 0; +}; + +struct Referrable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReferrableT NativeTableType; + typedef ReferrableBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return ReferrableTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4 + }; + uint64_t id() const { + return GetField(VT_ID, 0); + } + bool mutate_id(uint64_t _id = 0) { + return SetField(VT_ID, _id, 0); + } + bool KeyCompareLessThan(const Referrable *o) const { + return id() < o->id(); + } + int KeyCompareWithValue(uint64_t _id) const { + return static_cast(id() > _id) - static_cast(id() < _id); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ID, 8) && + verifier.EndTable(); + } + ReferrableT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReferrableBuilder { + typedef Referrable Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(uint64_t id) { + fbb_.AddElement(Referrable::VT_ID, id, 0); + } + explicit ReferrableBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateReferrable( + flatbuffers::FlatBufferBuilder &_fbb, + uint64_t id = 0) { + ReferrableBuilder builder_(_fbb); + builder_.add_id(id); + return builder_.Finish(); +} + +flatbuffers::Offset CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct MonsterT : public flatbuffers::NativeTable { + typedef Monster TableType; + flatbuffers::unique_ptr pos{}; + int16_t mana = 150; + int16_t hp = 100; + std::string name{}; + std::vector inventory{}; + MyGame::Example::Color color = MyGame::Example::Color_Blue; + MyGame::Example::AnyUnion test{}; + std::vector test4{}; + std::vector testarrayofstring{}; + std::vector> testarrayoftables{}; + flatbuffers::unique_ptr enemy{}; + std::vector testnestedflatbuffer{}; + flatbuffers::unique_ptr testempty{}; + bool testbool = false; + int32_t testhashs32_fnv1 = 0; + uint32_t testhashu32_fnv1 = 0; + int64_t testhashs64_fnv1 = 0; + uint64_t testhashu64_fnv1 = 0; + int32_t testhashs32_fnv1a = 0; + Stat *testhashu32_fnv1a = nullptr; + int64_t testhashs64_fnv1a = 0; + uint64_t testhashu64_fnv1a = 0; + std::vector testarrayofbools{}; + float testf = 3.14159f; + float testf2 = 3.0f; + float testf3 = 0.0f; + std::vector testarrayofstring2{}; + std::vector testarrayofsortedstruct{}; + std::vector flex{}; + std::vector test5{}; + std::vector vector_of_longs{}; + std::vector vector_of_doubles{}; + flatbuffers::unique_ptr parent_namespace_test{}; + std::vector> vector_of_referrables{}; + ReferrableT *single_weak_reference = nullptr; + std::vector vector_of_weak_references{}; + std::vector> vector_of_strong_referrables{}; + ReferrableT *co_owning_reference = nullptr; + std::vector> vector_of_co_owning_references{}; + ReferrableT *non_owning_reference = nullptr; + std::vector vector_of_non_owning_references{}; + MyGame::Example::AnyUniqueAliasesUnion any_unique{}; + MyGame::Example::AnyAmbiguousAliasesUnion any_ambiguous{}; + std::vector vector_of_enums{}; + MyGame::Example::Race signed_enum = MyGame::Example::Race_None; + std::vector testrequirednestedflatbuffer{}; + std::vector> scalar_key_sorted_tables{}; + MyGame::Example::Test native_inline{}; + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0); + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne; + MonsterT() = default; + MonsterT(const MonsterT &o); + MonsterT(MonsterT&&) FLATBUFFERS_NOEXCEPT = default; + MonsterT &operator=(MonsterT o) FLATBUFFERS_NOEXCEPT; +}; + +/// an example documentation comment: "monster object" +struct Monster FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MonsterT NativeTableType; + typedef MonsterBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return MonsterTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_POS = 4, + VT_MANA = 6, + VT_HP = 8, + VT_NAME = 10, + VT_INVENTORY = 14, + VT_COLOR = 16, + VT_TEST_TYPE = 18, + VT_TEST = 20, + VT_TEST4 = 22, + VT_TESTARRAYOFSTRING = 24, + VT_TESTARRAYOFTABLES = 26, + VT_ENEMY = 28, + VT_TESTNESTEDFLATBUFFER = 30, + VT_TESTEMPTY = 32, + VT_TESTBOOL = 34, + VT_TESTHASHS32_FNV1 = 36, + VT_TESTHASHU32_FNV1 = 38, + VT_TESTHASHS64_FNV1 = 40, + VT_TESTHASHU64_FNV1 = 42, + VT_TESTHASHS32_FNV1A = 44, + VT_TESTHASHU32_FNV1A = 46, + VT_TESTHASHS64_FNV1A = 48, + VT_TESTHASHU64_FNV1A = 50, + VT_TESTARRAYOFBOOLS = 52, + VT_TESTF = 54, + VT_TESTF2 = 56, + VT_TESTF3 = 58, + VT_TESTARRAYOFSTRING2 = 60, + VT_TESTARRAYOFSORTEDSTRUCT = 62, + VT_FLEX = 64, + VT_TEST5 = 66, + VT_VECTOR_OF_LONGS = 68, + VT_VECTOR_OF_DOUBLES = 70, + VT_PARENT_NAMESPACE_TEST = 72, + VT_VECTOR_OF_REFERRABLES = 74, + VT_SINGLE_WEAK_REFERENCE = 76, + VT_VECTOR_OF_WEAK_REFERENCES = 78, + VT_VECTOR_OF_STRONG_REFERRABLES = 80, + VT_CO_OWNING_REFERENCE = 82, + VT_VECTOR_OF_CO_OWNING_REFERENCES = 84, + VT_NON_OWNING_REFERENCE = 86, + VT_VECTOR_OF_NON_OWNING_REFERENCES = 88, + VT_ANY_UNIQUE_TYPE = 90, + VT_ANY_UNIQUE = 92, + VT_ANY_AMBIGUOUS_TYPE = 94, + VT_ANY_AMBIGUOUS = 96, + VT_VECTOR_OF_ENUMS = 98, + VT_SIGNED_ENUM = 100, + VT_TESTREQUIREDNESTEDFLATBUFFER = 102, + VT_SCALAR_KEY_SORTED_TABLES = 104, + VT_NATIVE_INLINE = 106, + VT_LONG_ENUM_NON_ENUM_DEFAULT = 108, + VT_LONG_ENUM_NORMAL_DEFAULT = 110 + }; + const MyGame::Example::Vec3 *pos() const { + return GetStruct(VT_POS); + } + MyGame::Example::Vec3 *mutable_pos() { + return GetStruct(VT_POS); + } + int16_t mana() const { + return GetField(VT_MANA, 150); + } + bool mutate_mana(int16_t _mana = 150) { + return SetField(VT_MANA, _mana, 150); + } + int16_t hp() const { + return GetField(VT_HP, 100); + } + bool mutate_hp(int16_t _hp = 100) { + return SetField(VT_HP, _hp, 100); + } + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + flatbuffers::String *mutable_name() { + return GetPointer(VT_NAME); + } + bool KeyCompareLessThan(const Monster *o) const { + return *name() < *o->name(); + } + int KeyCompareWithValue(const char *_name) const { + return strcmp(name()->c_str(), _name); + } + const flatbuffers::Vector *inventory() const { + return GetPointer *>(VT_INVENTORY); + } + flatbuffers::Vector *mutable_inventory() { + return GetPointer *>(VT_INVENTORY); + } + MyGame::Example::Color color() const { + return static_cast(GetField(VT_COLOR, 8)); + } + bool mutate_color(MyGame::Example::Color _color = static_cast(8)) { + return SetField(VT_COLOR, static_cast(_color), 8); + } + MyGame::Example::Any test_type() const { + return static_cast(GetField(VT_TEST_TYPE, 0)); + } + const void *test() const { + return GetPointer(VT_TEST); + } + template const T *test_as() const; + const MyGame::Example::Monster *test_as_Monster() const { + return test_type() == MyGame::Example::Any_Monster ? static_cast(test()) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnum *test_as_TestSimpleTableWithEnum() const { + return test_type() == MyGame::Example::Any_TestSimpleTableWithEnum ? static_cast(test()) : nullptr; + } + const MyGame::Example2::Monster *test_as_MyGame_Example2_Monster() const { + return test_type() == MyGame::Example::Any_MyGame_Example2_Monster ? static_cast(test()) : nullptr; + } + void *mutable_test() { + return GetPointer(VT_TEST); + } + const flatbuffers::Vector *test4() const { + return GetPointer *>(VT_TEST4); + } + flatbuffers::Vector *mutable_test4() { + return GetPointer *>(VT_TEST4); + } + const flatbuffers::Vector> *testarrayofstring() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } + flatbuffers::Vector> *mutable_testarrayofstring() { + return GetPointer> *>(VT_TESTARRAYOFSTRING); + } + /// an example documentation comment: this will end up in the generated code + /// multiline too + const flatbuffers::Vector> *testarrayoftables() const { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + flatbuffers::Vector> *mutable_testarrayoftables() { + return GetPointer> *>(VT_TESTARRAYOFTABLES); + } + const MyGame::Example::Monster *enemy() const { + return GetPointer(VT_ENEMY); + } + MyGame::Example::Monster *mutable_enemy() { + return GetPointer(VT_ENEMY); + } + const flatbuffers::Vector *testnestedflatbuffer() const { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + flatbuffers::Vector *mutable_testnestedflatbuffer() { + return GetPointer *>(VT_TESTNESTEDFLATBUFFER); + } + const MyGame::Example::Monster *testnestedflatbuffer_nested_root() const { + return flatbuffers::GetRoot(testnestedflatbuffer()->Data()); + } + const MyGame::Example::Stat *testempty() const { + return GetPointer(VT_TESTEMPTY); + } + MyGame::Example::Stat *mutable_testempty() { + return GetPointer(VT_TESTEMPTY); + } + bool testbool() const { + return GetField(VT_TESTBOOL, 0) != 0; + } + bool mutate_testbool(bool _testbool = 0) { + return SetField(VT_TESTBOOL, static_cast(_testbool), 0); + } + int32_t testhashs32_fnv1() const { + return GetField(VT_TESTHASHS32_FNV1, 0); + } + bool mutate_testhashs32_fnv1(int32_t _testhashs32_fnv1 = 0) { + return SetField(VT_TESTHASHS32_FNV1, _testhashs32_fnv1, 0); + } + uint32_t testhashu32_fnv1() const { + return GetField(VT_TESTHASHU32_FNV1, 0); + } + bool mutate_testhashu32_fnv1(uint32_t _testhashu32_fnv1 = 0) { + return SetField(VT_TESTHASHU32_FNV1, _testhashu32_fnv1, 0); + } + int64_t testhashs64_fnv1() const { + return GetField(VT_TESTHASHS64_FNV1, 0); + } + bool mutate_testhashs64_fnv1(int64_t _testhashs64_fnv1 = 0) { + return SetField(VT_TESTHASHS64_FNV1, _testhashs64_fnv1, 0); + } + uint64_t testhashu64_fnv1() const { + return GetField(VT_TESTHASHU64_FNV1, 0); + } + bool mutate_testhashu64_fnv1(uint64_t _testhashu64_fnv1 = 0) { + return SetField(VT_TESTHASHU64_FNV1, _testhashu64_fnv1, 0); + } + int32_t testhashs32_fnv1a() const { + return GetField(VT_TESTHASHS32_FNV1A, 0); + } + bool mutate_testhashs32_fnv1a(int32_t _testhashs32_fnv1a = 0) { + return SetField(VT_TESTHASHS32_FNV1A, _testhashs32_fnv1a, 0); + } + uint32_t testhashu32_fnv1a() const { + return GetField(VT_TESTHASHU32_FNV1A, 0); + } + bool mutate_testhashu32_fnv1a(uint32_t _testhashu32_fnv1a = 0) { + return SetField(VT_TESTHASHU32_FNV1A, _testhashu32_fnv1a, 0); + } + int64_t testhashs64_fnv1a() const { + return GetField(VT_TESTHASHS64_FNV1A, 0); + } + bool mutate_testhashs64_fnv1a(int64_t _testhashs64_fnv1a = 0) { + return SetField(VT_TESTHASHS64_FNV1A, _testhashs64_fnv1a, 0); + } + uint64_t testhashu64_fnv1a() const { + return GetField(VT_TESTHASHU64_FNV1A, 0); + } + bool mutate_testhashu64_fnv1a(uint64_t _testhashu64_fnv1a = 0) { + return SetField(VT_TESTHASHU64_FNV1A, _testhashu64_fnv1a, 0); + } + const flatbuffers::Vector *testarrayofbools() const { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + flatbuffers::Vector *mutable_testarrayofbools() { + return GetPointer *>(VT_TESTARRAYOFBOOLS); + } + float testf() const { + return GetField(VT_TESTF, 3.14159f); + } + bool mutate_testf(float _testf = 3.14159f) { + return SetField(VT_TESTF, _testf, 3.14159f); + } + float testf2() const { + return GetField(VT_TESTF2, 3.0f); + } + bool mutate_testf2(float _testf2 = 3.0f) { + return SetField(VT_TESTF2, _testf2, 3.0f); + } + float testf3() const { + return GetField(VT_TESTF3, 0.0f); + } + bool mutate_testf3(float _testf3 = 0.0f) { + return SetField(VT_TESTF3, _testf3, 0.0f); + } + const flatbuffers::Vector> *testarrayofstring2() const { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } + flatbuffers::Vector> *mutable_testarrayofstring2() { + return GetPointer> *>(VT_TESTARRAYOFSTRING2); + } + const flatbuffers::Vector *testarrayofsortedstruct() const { + return GetPointer *>(VT_TESTARRAYOFSORTEDSTRUCT); + } + flatbuffers::Vector *mutable_testarrayofsortedstruct() { + return GetPointer *>(VT_TESTARRAYOFSORTEDSTRUCT); + } + const flatbuffers::Vector *flex() const { + return GetPointer *>(VT_FLEX); + } + flatbuffers::Vector *mutable_flex() { + return GetPointer *>(VT_FLEX); + } + flexbuffers::Reference flex_flexbuffer_root() const { + return flexbuffers::GetRoot(flex()->Data(), flex()->size()); + } + const flatbuffers::Vector *test5() const { + return GetPointer *>(VT_TEST5); + } + flatbuffers::Vector *mutable_test5() { + return GetPointer *>(VT_TEST5); + } + const flatbuffers::Vector *vector_of_longs() const { + return GetPointer *>(VT_VECTOR_OF_LONGS); + } + flatbuffers::Vector *mutable_vector_of_longs() { + return GetPointer *>(VT_VECTOR_OF_LONGS); + } + const flatbuffers::Vector *vector_of_doubles() const { + return GetPointer *>(VT_VECTOR_OF_DOUBLES); + } + flatbuffers::Vector *mutable_vector_of_doubles() { + return GetPointer *>(VT_VECTOR_OF_DOUBLES); + } + const MyGame::InParentNamespace *parent_namespace_test() const { + return GetPointer(VT_PARENT_NAMESPACE_TEST); + } + MyGame::InParentNamespace *mutable_parent_namespace_test() { + return GetPointer(VT_PARENT_NAMESPACE_TEST); + } + const flatbuffers::Vector> *vector_of_referrables() const { + return GetPointer> *>(VT_VECTOR_OF_REFERRABLES); + } + flatbuffers::Vector> *mutable_vector_of_referrables() { + return GetPointer> *>(VT_VECTOR_OF_REFERRABLES); + } + uint64_t single_weak_reference() const { + return GetField(VT_SINGLE_WEAK_REFERENCE, 0); + } + bool mutate_single_weak_reference(uint64_t _single_weak_reference = 0) { + return SetField(VT_SINGLE_WEAK_REFERENCE, _single_weak_reference, 0); + } + const flatbuffers::Vector *vector_of_weak_references() const { + return GetPointer *>(VT_VECTOR_OF_WEAK_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_weak_references() { + return GetPointer *>(VT_VECTOR_OF_WEAK_REFERENCES); + } + const flatbuffers::Vector> *vector_of_strong_referrables() const { + return GetPointer> *>(VT_VECTOR_OF_STRONG_REFERRABLES); + } + flatbuffers::Vector> *mutable_vector_of_strong_referrables() { + return GetPointer> *>(VT_VECTOR_OF_STRONG_REFERRABLES); + } + uint64_t co_owning_reference() const { + return GetField(VT_CO_OWNING_REFERENCE, 0); + } + bool mutate_co_owning_reference(uint64_t _co_owning_reference = 0) { + return SetField(VT_CO_OWNING_REFERENCE, _co_owning_reference, 0); + } + const flatbuffers::Vector *vector_of_co_owning_references() const { + return GetPointer *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_co_owning_references() { + return GetPointer *>(VT_VECTOR_OF_CO_OWNING_REFERENCES); + } + uint64_t non_owning_reference() const { + return GetField(VT_NON_OWNING_REFERENCE, 0); + } + bool mutate_non_owning_reference(uint64_t _non_owning_reference = 0) { + return SetField(VT_NON_OWNING_REFERENCE, _non_owning_reference, 0); + } + const flatbuffers::Vector *vector_of_non_owning_references() const { + return GetPointer *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); + } + flatbuffers::Vector *mutable_vector_of_non_owning_references() { + return GetPointer *>(VT_VECTOR_OF_NON_OWNING_REFERENCES); + } + MyGame::Example::AnyUniqueAliases any_unique_type() const { + return static_cast(GetField(VT_ANY_UNIQUE_TYPE, 0)); + } + const void *any_unique() const { + return GetPointer(VT_ANY_UNIQUE); + } + template const T *any_unique_as() const; + const MyGame::Example::Monster *any_unique_as_M() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_M ? static_cast(any_unique()) : nullptr; + } + const MyGame::Example::TestSimpleTableWithEnum *any_unique_as_TS() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_TS ? static_cast(any_unique()) : nullptr; + } + const MyGame::Example2::Monster *any_unique_as_M2() const { + return any_unique_type() == MyGame::Example::AnyUniqueAliases_M2 ? static_cast(any_unique()) : nullptr; + } + void *mutable_any_unique() { + return GetPointer(VT_ANY_UNIQUE); + } + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type() const { + return static_cast(GetField(VT_ANY_AMBIGUOUS_TYPE, 0)); + } + const void *any_ambiguous() const { + return GetPointer(VT_ANY_AMBIGUOUS); + } + const MyGame::Example::Monster *any_ambiguous_as_M1() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M1 ? static_cast(any_ambiguous()) : nullptr; + } + const MyGame::Example::Monster *any_ambiguous_as_M2() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M2 ? static_cast(any_ambiguous()) : nullptr; + } + const MyGame::Example::Monster *any_ambiguous_as_M3() const { + return any_ambiguous_type() == MyGame::Example::AnyAmbiguousAliases_M3 ? static_cast(any_ambiguous()) : nullptr; + } + void *mutable_any_ambiguous() { + return GetPointer(VT_ANY_AMBIGUOUS); + } + const flatbuffers::Vector *vector_of_enums() const { + return GetPointer *>(VT_VECTOR_OF_ENUMS); + } + flatbuffers::Vector *mutable_vector_of_enums() { + return GetPointer *>(VT_VECTOR_OF_ENUMS); + } + MyGame::Example::Race signed_enum() const { + return static_cast(GetField(VT_SIGNED_ENUM, -1)); + } + bool mutate_signed_enum(MyGame::Example::Race _signed_enum = static_cast(-1)) { + return SetField(VT_SIGNED_ENUM, static_cast(_signed_enum), -1); + } + const flatbuffers::Vector *testrequirednestedflatbuffer() const { + return GetPointer *>(VT_TESTREQUIREDNESTEDFLATBUFFER); + } + flatbuffers::Vector *mutable_testrequirednestedflatbuffer() { + return GetPointer *>(VT_TESTREQUIREDNESTEDFLATBUFFER); + } + const MyGame::Example::Monster *testrequirednestedflatbuffer_nested_root() const { + return flatbuffers::GetRoot(testrequirednestedflatbuffer()->Data()); + } + const flatbuffers::Vector> *scalar_key_sorted_tables() const { + return GetPointer> *>(VT_SCALAR_KEY_SORTED_TABLES); + } + flatbuffers::Vector> *mutable_scalar_key_sorted_tables() { + return GetPointer> *>(VT_SCALAR_KEY_SORTED_TABLES); + } + const MyGame::Example::Test *native_inline() const { + return GetStruct(VT_NATIVE_INLINE); + } + MyGame::Example::Test *mutable_native_inline() { + return GetStruct(VT_NATIVE_INLINE); + } + MyGame::Example::LongEnum long_enum_non_enum_default() const { + return static_cast(GetField(VT_LONG_ENUM_NON_ENUM_DEFAULT, 0)); + } + bool mutate_long_enum_non_enum_default(MyGame::Example::LongEnum _long_enum_non_enum_default = static_cast(0)) { + return SetField(VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast(_long_enum_non_enum_default), 0); + } + MyGame::Example::LongEnum long_enum_normal_default() const { + return static_cast(GetField(VT_LONG_ENUM_NORMAL_DEFAULT, 2ULL)); + } + bool mutate_long_enum_normal_default(MyGame::Example::LongEnum _long_enum_normal_default = static_cast(2ULL)) { + return SetField(VT_LONG_ENUM_NORMAL_DEFAULT, static_cast(_long_enum_normal_default), 2ULL); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_POS, 8) && + VerifyField(verifier, VT_MANA, 2) && + VerifyField(verifier, VT_HP, 2) && + VerifyOffsetRequired(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_INVENTORY) && + verifier.VerifyVector(inventory()) && + VerifyField(verifier, VT_COLOR, 1) && + VerifyField(verifier, VT_TEST_TYPE, 1) && + VerifyOffset(verifier, VT_TEST) && + VerifyAny(verifier, test(), test_type()) && + VerifyOffset(verifier, VT_TEST4) && + verifier.VerifyVector(test4()) && + VerifyOffset(verifier, VT_TESTARRAYOFSTRING) && + verifier.VerifyVector(testarrayofstring()) && + verifier.VerifyVectorOfStrings(testarrayofstring()) && + VerifyOffset(verifier, VT_TESTARRAYOFTABLES) && + verifier.VerifyVector(testarrayoftables()) && + verifier.VerifyVectorOfTables(testarrayoftables()) && + VerifyOffset(verifier, VT_ENEMY) && + verifier.VerifyTable(enemy()) && + VerifyOffset(verifier, VT_TESTNESTEDFLATBUFFER) && + verifier.VerifyVector(testnestedflatbuffer()) && + verifier.VerifyNestedFlatBuffer(testnestedflatbuffer(), nullptr) && + VerifyOffset(verifier, VT_TESTEMPTY) && + verifier.VerifyTable(testempty()) && + VerifyField(verifier, VT_TESTBOOL, 1) && + VerifyField(verifier, VT_TESTHASHS32_FNV1, 4) && + VerifyField(verifier, VT_TESTHASHU32_FNV1, 4) && + VerifyField(verifier, VT_TESTHASHS64_FNV1, 8) && + VerifyField(verifier, VT_TESTHASHU64_FNV1, 8) && + VerifyField(verifier, VT_TESTHASHS32_FNV1A, 4) && + VerifyField(verifier, VT_TESTHASHU32_FNV1A, 4) && + VerifyField(verifier, VT_TESTHASHS64_FNV1A, 8) && + VerifyField(verifier, VT_TESTHASHU64_FNV1A, 8) && + VerifyOffset(verifier, VT_TESTARRAYOFBOOLS) && + verifier.VerifyVector(testarrayofbools()) && + VerifyField(verifier, VT_TESTF, 4) && + VerifyField(verifier, VT_TESTF2, 4) && + VerifyField(verifier, VT_TESTF3, 4) && + VerifyOffset(verifier, VT_TESTARRAYOFSTRING2) && + verifier.VerifyVector(testarrayofstring2()) && + verifier.VerifyVectorOfStrings(testarrayofstring2()) && + VerifyOffset(verifier, VT_TESTARRAYOFSORTEDSTRUCT) && + verifier.VerifyVector(testarrayofsortedstruct()) && + VerifyOffset(verifier, VT_FLEX) && + verifier.VerifyVector(flex()) && + flexbuffers::VerifyNestedFlexBuffer(flex(), verifier) && + VerifyOffset(verifier, VT_TEST5) && + verifier.VerifyVector(test5()) && + VerifyOffset(verifier, VT_VECTOR_OF_LONGS) && + verifier.VerifyVector(vector_of_longs()) && + VerifyOffset(verifier, VT_VECTOR_OF_DOUBLES) && + verifier.VerifyVector(vector_of_doubles()) && + VerifyOffset(verifier, VT_PARENT_NAMESPACE_TEST) && + verifier.VerifyTable(parent_namespace_test()) && + VerifyOffset(verifier, VT_VECTOR_OF_REFERRABLES) && + verifier.VerifyVector(vector_of_referrables()) && + verifier.VerifyVectorOfTables(vector_of_referrables()) && + VerifyField(verifier, VT_SINGLE_WEAK_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_WEAK_REFERENCES) && + verifier.VerifyVector(vector_of_weak_references()) && + VerifyOffset(verifier, VT_VECTOR_OF_STRONG_REFERRABLES) && + verifier.VerifyVector(vector_of_strong_referrables()) && + verifier.VerifyVectorOfTables(vector_of_strong_referrables()) && + VerifyField(verifier, VT_CO_OWNING_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_CO_OWNING_REFERENCES) && + verifier.VerifyVector(vector_of_co_owning_references()) && + VerifyField(verifier, VT_NON_OWNING_REFERENCE, 8) && + VerifyOffset(verifier, VT_VECTOR_OF_NON_OWNING_REFERENCES) && + verifier.VerifyVector(vector_of_non_owning_references()) && + VerifyField(verifier, VT_ANY_UNIQUE_TYPE, 1) && + VerifyOffset(verifier, VT_ANY_UNIQUE) && + VerifyAnyUniqueAliases(verifier, any_unique(), any_unique_type()) && + VerifyField(verifier, VT_ANY_AMBIGUOUS_TYPE, 1) && + VerifyOffset(verifier, VT_ANY_AMBIGUOUS) && + VerifyAnyAmbiguousAliases(verifier, any_ambiguous(), any_ambiguous_type()) && + VerifyOffset(verifier, VT_VECTOR_OF_ENUMS) && + verifier.VerifyVector(vector_of_enums()) && + VerifyField(verifier, VT_SIGNED_ENUM, 1) && + VerifyOffset(verifier, VT_TESTREQUIREDNESTEDFLATBUFFER) && + verifier.VerifyVector(testrequirednestedflatbuffer()) && + verifier.VerifyNestedFlatBuffer(testrequirednestedflatbuffer(), nullptr) && + VerifyOffset(verifier, VT_SCALAR_KEY_SORTED_TABLES) && + verifier.VerifyVector(scalar_key_sorted_tables()) && + verifier.VerifyVectorOfTables(scalar_key_sorted_tables()) && + VerifyField(verifier, VT_NATIVE_INLINE, 2) && + VerifyField(verifier, VT_LONG_ENUM_NON_ENUM_DEFAULT, 8) && + VerifyField(verifier, VT_LONG_ENUM_NORMAL_DEFAULT, 8) && + verifier.EndTable(); + } + MonsterT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +template<> inline const MyGame::Example::Monster *Monster::test_as() const { + return test_as_Monster(); +} + +template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::test_as() const { + return test_as_TestSimpleTableWithEnum(); +} + +template<> inline const MyGame::Example2::Monster *Monster::test_as() const { + return test_as_MyGame_Example2_Monster(); +} + +template<> inline const MyGame::Example::Monster *Monster::any_unique_as() const { + return any_unique_as_M(); +} + +template<> inline const MyGame::Example::TestSimpleTableWithEnum *Monster::any_unique_as() const { + return any_unique_as_TS(); +} + +template<> inline const MyGame::Example2::Monster *Monster::any_unique_as() const { + return any_unique_as_M2(); +} + +struct MonsterBuilder { + typedef Monster Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_pos(const MyGame::Example::Vec3 *pos) { + fbb_.AddStruct(Monster::VT_POS, pos); + } + void add_mana(int16_t mana) { + fbb_.AddElement(Monster::VT_MANA, mana, 150); + } + void add_hp(int16_t hp) { + fbb_.AddElement(Monster::VT_HP, hp, 100); + } + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(Monster::VT_NAME, name); + } + void add_inventory(flatbuffers::Offset> inventory) { + fbb_.AddOffset(Monster::VT_INVENTORY, inventory); + } + void add_color(MyGame::Example::Color color) { + fbb_.AddElement(Monster::VT_COLOR, static_cast(color), 8); + } + void add_test_type(MyGame::Example::Any test_type) { + fbb_.AddElement(Monster::VT_TEST_TYPE, static_cast(test_type), 0); + } + void add_test(flatbuffers::Offset test) { + fbb_.AddOffset(Monster::VT_TEST, test); + } + void add_test4(flatbuffers::Offset> test4) { + fbb_.AddOffset(Monster::VT_TEST4, test4); + } + void add_testarrayofstring(flatbuffers::Offset>> testarrayofstring) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING, testarrayofstring); + } + void add_testarrayoftables(flatbuffers::Offset>> testarrayoftables) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFTABLES, testarrayoftables); + } + void add_enemy(flatbuffers::Offset enemy) { + fbb_.AddOffset(Monster::VT_ENEMY, enemy); + } + void add_testnestedflatbuffer(flatbuffers::Offset> testnestedflatbuffer) { + fbb_.AddOffset(Monster::VT_TESTNESTEDFLATBUFFER, testnestedflatbuffer); + } + void add_testempty(flatbuffers::Offset testempty) { + fbb_.AddOffset(Monster::VT_TESTEMPTY, testempty); + } + void add_testbool(bool testbool) { + fbb_.AddElement(Monster::VT_TESTBOOL, static_cast(testbool), 0); + } + void add_testhashs32_fnv1(int32_t testhashs32_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHS32_FNV1, testhashs32_fnv1, 0); + } + void add_testhashu32_fnv1(uint32_t testhashu32_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHU32_FNV1, testhashu32_fnv1, 0); + } + void add_testhashs64_fnv1(int64_t testhashs64_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHS64_FNV1, testhashs64_fnv1, 0); + } + void add_testhashu64_fnv1(uint64_t testhashu64_fnv1) { + fbb_.AddElement(Monster::VT_TESTHASHU64_FNV1, testhashu64_fnv1, 0); + } + void add_testhashs32_fnv1a(int32_t testhashs32_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHS32_FNV1A, testhashs32_fnv1a, 0); + } + void add_testhashu32_fnv1a(uint32_t testhashu32_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHU32_FNV1A, testhashu32_fnv1a, 0); + } + void add_testhashs64_fnv1a(int64_t testhashs64_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHS64_FNV1A, testhashs64_fnv1a, 0); + } + void add_testhashu64_fnv1a(uint64_t testhashu64_fnv1a) { + fbb_.AddElement(Monster::VT_TESTHASHU64_FNV1A, testhashu64_fnv1a, 0); + } + void add_testarrayofbools(flatbuffers::Offset> testarrayofbools) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFBOOLS, testarrayofbools); + } + void add_testf(float testf) { + fbb_.AddElement(Monster::VT_TESTF, testf, 3.14159f); + } + void add_testf2(float testf2) { + fbb_.AddElement(Monster::VT_TESTF2, testf2, 3.0f); + } + void add_testf3(float testf3) { + fbb_.AddElement(Monster::VT_TESTF3, testf3, 0.0f); + } + void add_testarrayofstring2(flatbuffers::Offset>> testarrayofstring2) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSTRING2, testarrayofstring2); + } + void add_testarrayofsortedstruct(flatbuffers::Offset> testarrayofsortedstruct) { + fbb_.AddOffset(Monster::VT_TESTARRAYOFSORTEDSTRUCT, testarrayofsortedstruct); + } + void add_flex(flatbuffers::Offset> flex) { + fbb_.AddOffset(Monster::VT_FLEX, flex); + } + void add_test5(flatbuffers::Offset> test5) { + fbb_.AddOffset(Monster::VT_TEST5, test5); + } + void add_vector_of_longs(flatbuffers::Offset> vector_of_longs) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_LONGS, vector_of_longs); + } + void add_vector_of_doubles(flatbuffers::Offset> vector_of_doubles) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_DOUBLES, vector_of_doubles); + } + void add_parent_namespace_test(flatbuffers::Offset parent_namespace_test) { + fbb_.AddOffset(Monster::VT_PARENT_NAMESPACE_TEST, parent_namespace_test); + } + void add_vector_of_referrables(flatbuffers::Offset>> vector_of_referrables) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_REFERRABLES, vector_of_referrables); + } + void add_single_weak_reference(uint64_t single_weak_reference) { + fbb_.AddElement(Monster::VT_SINGLE_WEAK_REFERENCE, single_weak_reference, 0); + } + void add_vector_of_weak_references(flatbuffers::Offset> vector_of_weak_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_WEAK_REFERENCES, vector_of_weak_references); + } + void add_vector_of_strong_referrables(flatbuffers::Offset>> vector_of_strong_referrables) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_STRONG_REFERRABLES, vector_of_strong_referrables); + } + void add_co_owning_reference(uint64_t co_owning_reference) { + fbb_.AddElement(Monster::VT_CO_OWNING_REFERENCE, co_owning_reference, 0); + } + void add_vector_of_co_owning_references(flatbuffers::Offset> vector_of_co_owning_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_CO_OWNING_REFERENCES, vector_of_co_owning_references); + } + void add_non_owning_reference(uint64_t non_owning_reference) { + fbb_.AddElement(Monster::VT_NON_OWNING_REFERENCE, non_owning_reference, 0); + } + void add_vector_of_non_owning_references(flatbuffers::Offset> vector_of_non_owning_references) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_NON_OWNING_REFERENCES, vector_of_non_owning_references); + } + void add_any_unique_type(MyGame::Example::AnyUniqueAliases any_unique_type) { + fbb_.AddElement(Monster::VT_ANY_UNIQUE_TYPE, static_cast(any_unique_type), 0); + } + void add_any_unique(flatbuffers::Offset any_unique) { + fbb_.AddOffset(Monster::VT_ANY_UNIQUE, any_unique); + } + void add_any_ambiguous_type(MyGame::Example::AnyAmbiguousAliases any_ambiguous_type) { + fbb_.AddElement(Monster::VT_ANY_AMBIGUOUS_TYPE, static_cast(any_ambiguous_type), 0); + } + void add_any_ambiguous(flatbuffers::Offset any_ambiguous) { + fbb_.AddOffset(Monster::VT_ANY_AMBIGUOUS, any_ambiguous); + } + void add_vector_of_enums(flatbuffers::Offset> vector_of_enums) { + fbb_.AddOffset(Monster::VT_VECTOR_OF_ENUMS, vector_of_enums); + } + void add_signed_enum(MyGame::Example::Race signed_enum) { + fbb_.AddElement(Monster::VT_SIGNED_ENUM, static_cast(signed_enum), -1); + } + void add_testrequirednestedflatbuffer(flatbuffers::Offset> testrequirednestedflatbuffer) { + fbb_.AddOffset(Monster::VT_TESTREQUIREDNESTEDFLATBUFFER, testrequirednestedflatbuffer); + } + void add_scalar_key_sorted_tables(flatbuffers::Offset>> scalar_key_sorted_tables) { + fbb_.AddOffset(Monster::VT_SCALAR_KEY_SORTED_TABLES, scalar_key_sorted_tables); + } + void add_native_inline(const MyGame::Example::Test *native_inline) { + fbb_.AddStruct(Monster::VT_NATIVE_INLINE, native_inline); + } + void add_long_enum_non_enum_default(MyGame::Example::LongEnum long_enum_non_enum_default) { + fbb_.AddElement(Monster::VT_LONG_ENUM_NON_ENUM_DEFAULT, static_cast(long_enum_non_enum_default), 0); + } + void add_long_enum_normal_default(MyGame::Example::LongEnum long_enum_normal_default) { + fbb_.AddElement(Monster::VT_LONG_ENUM_NORMAL_DEFAULT, static_cast(long_enum_normal_default), 2ULL); + } + explicit MonsterBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + fbb_.Required(o, Monster::VT_NAME); + return o; + } +}; + +inline flatbuffers::Offset CreateMonster( + flatbuffers::FlatBufferBuilder &_fbb, + const MyGame::Example::Vec3 *pos = nullptr, + int16_t mana = 150, + int16_t hp = 100, + flatbuffers::Offset name = 0, + flatbuffers::Offset> inventory = 0, + MyGame::Example::Color color = MyGame::Example::Color_Blue, + MyGame::Example::Any test_type = MyGame::Example::Any_NONE, + flatbuffers::Offset test = 0, + flatbuffers::Offset> test4 = 0, + flatbuffers::Offset>> testarrayofstring = 0, + flatbuffers::Offset>> testarrayoftables = 0, + flatbuffers::Offset enemy = 0, + flatbuffers::Offset> testnestedflatbuffer = 0, + flatbuffers::Offset testempty = 0, + bool testbool = false, + int32_t testhashs32_fnv1 = 0, + uint32_t testhashu32_fnv1 = 0, + int64_t testhashs64_fnv1 = 0, + uint64_t testhashu64_fnv1 = 0, + int32_t testhashs32_fnv1a = 0, + uint32_t testhashu32_fnv1a = 0, + int64_t testhashs64_fnv1a = 0, + uint64_t testhashu64_fnv1a = 0, + flatbuffers::Offset> testarrayofbools = 0, + float testf = 3.14159f, + float testf2 = 3.0f, + float testf3 = 0.0f, + flatbuffers::Offset>> testarrayofstring2 = 0, + flatbuffers::Offset> testarrayofsortedstruct = 0, + flatbuffers::Offset> flex = 0, + flatbuffers::Offset> test5 = 0, + flatbuffers::Offset> vector_of_longs = 0, + flatbuffers::Offset> vector_of_doubles = 0, + flatbuffers::Offset parent_namespace_test = 0, + flatbuffers::Offset>> vector_of_referrables = 0, + uint64_t single_weak_reference = 0, + flatbuffers::Offset> vector_of_weak_references = 0, + flatbuffers::Offset>> vector_of_strong_referrables = 0, + uint64_t co_owning_reference = 0, + flatbuffers::Offset> vector_of_co_owning_references = 0, + uint64_t non_owning_reference = 0, + flatbuffers::Offset> vector_of_non_owning_references = 0, + MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE, + flatbuffers::Offset any_unique = 0, + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE, + flatbuffers::Offset any_ambiguous = 0, + flatbuffers::Offset> vector_of_enums = 0, + MyGame::Example::Race signed_enum = MyGame::Example::Race_None, + flatbuffers::Offset> testrequirednestedflatbuffer = 0, + flatbuffers::Offset>> scalar_key_sorted_tables = 0, + const MyGame::Example::Test *native_inline = nullptr, + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0), + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) { + MonsterBuilder builder_(_fbb); + builder_.add_long_enum_normal_default(long_enum_normal_default); + builder_.add_long_enum_non_enum_default(long_enum_non_enum_default); + builder_.add_non_owning_reference(non_owning_reference); + builder_.add_co_owning_reference(co_owning_reference); + builder_.add_single_weak_reference(single_weak_reference); + builder_.add_testhashu64_fnv1a(testhashu64_fnv1a); + builder_.add_testhashs64_fnv1a(testhashs64_fnv1a); + builder_.add_testhashu64_fnv1(testhashu64_fnv1); + builder_.add_testhashs64_fnv1(testhashs64_fnv1); + builder_.add_native_inline(native_inline); + builder_.add_scalar_key_sorted_tables(scalar_key_sorted_tables); + builder_.add_testrequirednestedflatbuffer(testrequirednestedflatbuffer); + builder_.add_vector_of_enums(vector_of_enums); + builder_.add_any_ambiguous(any_ambiguous); + builder_.add_any_unique(any_unique); + builder_.add_vector_of_non_owning_references(vector_of_non_owning_references); + builder_.add_vector_of_co_owning_references(vector_of_co_owning_references); + builder_.add_vector_of_strong_referrables(vector_of_strong_referrables); + builder_.add_vector_of_weak_references(vector_of_weak_references); + builder_.add_vector_of_referrables(vector_of_referrables); + builder_.add_parent_namespace_test(parent_namespace_test); + builder_.add_vector_of_doubles(vector_of_doubles); + builder_.add_vector_of_longs(vector_of_longs); + builder_.add_test5(test5); + builder_.add_flex(flex); + builder_.add_testarrayofsortedstruct(testarrayofsortedstruct); + builder_.add_testarrayofstring2(testarrayofstring2); + builder_.add_testf3(testf3); + builder_.add_testf2(testf2); + builder_.add_testf(testf); + builder_.add_testarrayofbools(testarrayofbools); + builder_.add_testhashu32_fnv1a(testhashu32_fnv1a); + builder_.add_testhashs32_fnv1a(testhashs32_fnv1a); + builder_.add_testhashu32_fnv1(testhashu32_fnv1); + builder_.add_testhashs32_fnv1(testhashs32_fnv1); + builder_.add_testempty(testempty); + builder_.add_testnestedflatbuffer(testnestedflatbuffer); + builder_.add_enemy(enemy); + builder_.add_testarrayoftables(testarrayoftables); + builder_.add_testarrayofstring(testarrayofstring); + builder_.add_test4(test4); + builder_.add_test(test); + builder_.add_inventory(inventory); + builder_.add_name(name); + builder_.add_pos(pos); + builder_.add_hp(hp); + builder_.add_mana(mana); + builder_.add_signed_enum(signed_enum); + builder_.add_any_ambiguous_type(any_ambiguous_type); + builder_.add_any_unique_type(any_unique_type); + builder_.add_testbool(testbool); + builder_.add_test_type(test_type); + builder_.add_color(color); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateMonsterDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const MyGame::Example::Vec3 *pos = nullptr, + int16_t mana = 150, + int16_t hp = 100, + const char *name = nullptr, + const std::vector *inventory = nullptr, + MyGame::Example::Color color = MyGame::Example::Color_Blue, + MyGame::Example::Any test_type = MyGame::Example::Any_NONE, + flatbuffers::Offset test = 0, + const std::vector *test4 = nullptr, + const std::vector> *testarrayofstring = nullptr, + std::vector> *testarrayoftables = nullptr, + flatbuffers::Offset enemy = 0, + const std::vector *testnestedflatbuffer = nullptr, + flatbuffers::Offset testempty = 0, + bool testbool = false, + int32_t testhashs32_fnv1 = 0, + uint32_t testhashu32_fnv1 = 0, + int64_t testhashs64_fnv1 = 0, + uint64_t testhashu64_fnv1 = 0, + int32_t testhashs32_fnv1a = 0, + uint32_t testhashu32_fnv1a = 0, + int64_t testhashs64_fnv1a = 0, + uint64_t testhashu64_fnv1a = 0, + const std::vector *testarrayofbools = nullptr, + float testf = 3.14159f, + float testf2 = 3.0f, + float testf3 = 0.0f, + const std::vector> *testarrayofstring2 = nullptr, + std::vector *testarrayofsortedstruct = nullptr, + const std::vector *flex = nullptr, + const std::vector *test5 = nullptr, + const std::vector *vector_of_longs = nullptr, + const std::vector *vector_of_doubles = nullptr, + flatbuffers::Offset parent_namespace_test = 0, + std::vector> *vector_of_referrables = nullptr, + uint64_t single_weak_reference = 0, + const std::vector *vector_of_weak_references = nullptr, + std::vector> *vector_of_strong_referrables = nullptr, + uint64_t co_owning_reference = 0, + const std::vector *vector_of_co_owning_references = nullptr, + uint64_t non_owning_reference = 0, + const std::vector *vector_of_non_owning_references = nullptr, + MyGame::Example::AnyUniqueAliases any_unique_type = MyGame::Example::AnyUniqueAliases_NONE, + flatbuffers::Offset any_unique = 0, + MyGame::Example::AnyAmbiguousAliases any_ambiguous_type = MyGame::Example::AnyAmbiguousAliases_NONE, + flatbuffers::Offset any_ambiguous = 0, + const std::vector *vector_of_enums = nullptr, + MyGame::Example::Race signed_enum = MyGame::Example::Race_None, + const std::vector *testrequirednestedflatbuffer = nullptr, + std::vector> *scalar_key_sorted_tables = nullptr, + const MyGame::Example::Test *native_inline = nullptr, + MyGame::Example::LongEnum long_enum_non_enum_default = static_cast(0), + MyGame::Example::LongEnum long_enum_normal_default = MyGame::Example::LongEnum_LongOne) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto inventory__ = inventory ? _fbb.CreateVector(*inventory) : 0; + auto test4__ = test4 ? _fbb.CreateVectorOfStructs(*test4) : 0; + auto testarrayofstring__ = testarrayofstring ? _fbb.CreateVector>(*testarrayofstring) : 0; + auto testarrayoftables__ = testarrayoftables ? _fbb.CreateVectorOfSortedTables(testarrayoftables) : 0; + auto testnestedflatbuffer__ = testnestedflatbuffer ? _fbb.CreateVector(*testnestedflatbuffer) : 0; + auto testarrayofbools__ = testarrayofbools ? _fbb.CreateVector(*testarrayofbools) : 0; + auto testarrayofstring2__ = testarrayofstring2 ? _fbb.CreateVector>(*testarrayofstring2) : 0; + auto testarrayofsortedstruct__ = testarrayofsortedstruct ? _fbb.CreateVectorOfSortedStructs(testarrayofsortedstruct) : 0; + auto flex__ = flex ? _fbb.CreateVector(*flex) : 0; + auto test5__ = test5 ? _fbb.CreateVectorOfStructs(*test5) : 0; + auto vector_of_longs__ = vector_of_longs ? _fbb.CreateVector(*vector_of_longs) : 0; + auto vector_of_doubles__ = vector_of_doubles ? _fbb.CreateVector(*vector_of_doubles) : 0; + auto vector_of_referrables__ = vector_of_referrables ? _fbb.CreateVectorOfSortedTables(vector_of_referrables) : 0; + auto vector_of_weak_references__ = vector_of_weak_references ? _fbb.CreateVector(*vector_of_weak_references) : 0; + auto vector_of_strong_referrables__ = vector_of_strong_referrables ? _fbb.CreateVectorOfSortedTables(vector_of_strong_referrables) : 0; + auto vector_of_co_owning_references__ = vector_of_co_owning_references ? _fbb.CreateVector(*vector_of_co_owning_references) : 0; + auto vector_of_non_owning_references__ = vector_of_non_owning_references ? _fbb.CreateVector(*vector_of_non_owning_references) : 0; + auto vector_of_enums__ = vector_of_enums ? _fbb.CreateVector(*vector_of_enums) : 0; + auto testrequirednestedflatbuffer__ = testrequirednestedflatbuffer ? _fbb.CreateVector(*testrequirednestedflatbuffer) : 0; + auto scalar_key_sorted_tables__ = scalar_key_sorted_tables ? _fbb.CreateVectorOfSortedTables(scalar_key_sorted_tables) : 0; + return MyGame::Example::CreateMonster( + _fbb, + pos, + mana, + hp, + name__, + inventory__, + color, + test_type, + test, + test4__, + testarrayofstring__, + testarrayoftables__, + enemy, + testnestedflatbuffer__, + testempty, + testbool, + testhashs32_fnv1, + testhashu32_fnv1, + testhashs64_fnv1, + testhashu64_fnv1, + testhashs32_fnv1a, + testhashu32_fnv1a, + testhashs64_fnv1a, + testhashu64_fnv1a, + testarrayofbools__, + testf, + testf2, + testf3, + testarrayofstring2__, + testarrayofsortedstruct__, + flex__, + test5__, + vector_of_longs__, + vector_of_doubles__, + parent_namespace_test, + vector_of_referrables__, + single_weak_reference, + vector_of_weak_references__, + vector_of_strong_referrables__, + co_owning_reference, + vector_of_co_owning_references__, + non_owning_reference, + vector_of_non_owning_references__, + any_unique_type, + any_unique, + any_ambiguous_type, + any_ambiguous, + vector_of_enums__, + signed_enum, + testrequirednestedflatbuffer__, + scalar_key_sorted_tables__, + native_inline, + long_enum_non_enum_default, + long_enum_normal_default); +} + +flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct TypeAliasesT : public flatbuffers::NativeTable { + typedef TypeAliases TableType; + int8_t i8 = 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; + std::vector v8{}; + std::vector vf64{}; +}; + +struct TypeAliases FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TypeAliasesT NativeTableType; + typedef TypeAliasesBuilder Builder; + static const flatbuffers::TypeTable *MiniReflectTypeTable() { + return TypeAliasesTypeTable(); + } + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_I8 = 4, + VT_U8 = 6, + VT_I16 = 8, + VT_U16 = 10, + VT_I32 = 12, + VT_U32 = 14, + VT_I64 = 16, + VT_U64 = 18, + VT_F32 = 20, + VT_F64 = 22, + VT_V8 = 24, + VT_VF64 = 26 + }; + int8_t i8() const { + return GetField(VT_I8, 0); + } + bool mutate_i8(int8_t _i8 = 0) { + return SetField(VT_I8, _i8, 0); + } + uint8_t u8() const { + return GetField(VT_U8, 0); + } + bool mutate_u8(uint8_t _u8 = 0) { + return SetField(VT_U8, _u8, 0); + } + int16_t i16() const { + return GetField(VT_I16, 0); + } + bool mutate_i16(int16_t _i16 = 0) { + return SetField(VT_I16, _i16, 0); + } + uint16_t u16() const { + return GetField(VT_U16, 0); + } + bool mutate_u16(uint16_t _u16 = 0) { + return SetField(VT_U16, _u16, 0); + } + int32_t i32() const { + return GetField(VT_I32, 0); + } + bool mutate_i32(int32_t _i32 = 0) { + return SetField(VT_I32, _i32, 0); + } + uint32_t u32() const { + return GetField(VT_U32, 0); + } + bool mutate_u32(uint32_t _u32 = 0) { + return SetField(VT_U32, _u32, 0); + } + int64_t i64() const { + return GetField(VT_I64, 0); + } + bool mutate_i64(int64_t _i64 = 0) { + return SetField(VT_I64, _i64, 0); + } + uint64_t u64() const { + return GetField(VT_U64, 0); + } + bool mutate_u64(uint64_t _u64 = 0) { + return SetField(VT_U64, _u64, 0); + } + float f32() const { + return GetField(VT_F32, 0.0f); + } + bool mutate_f32(float _f32 = 0.0f) { + return SetField(VT_F32, _f32, 0.0f); + } + double f64() const { + return GetField(VT_F64, 0.0); + } + bool mutate_f64(double _f64 = 0.0) { + return SetField(VT_F64, _f64, 0.0); + } + const flatbuffers::Vector *v8() const { + return GetPointer *>(VT_V8); + } + flatbuffers::Vector *mutable_v8() { + return GetPointer *>(VT_V8); + } + const flatbuffers::Vector *vf64() const { + return GetPointer *>(VT_VF64); + } + flatbuffers::Vector *mutable_vf64() { + return GetPointer *>(VT_VF64); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_I8, 1) && + VerifyField(verifier, VT_U8, 1) && + VerifyField(verifier, VT_I16, 2) && + VerifyField(verifier, VT_U16, 2) && + VerifyField(verifier, VT_I32, 4) && + VerifyField(verifier, VT_U32, 4) && + VerifyField(verifier, VT_I64, 8) && + VerifyField(verifier, VT_U64, 8) && + VerifyField(verifier, VT_F32, 4) && + VerifyField(verifier, VT_F64, 8) && + VerifyOffset(verifier, VT_V8) && + verifier.VerifyVector(v8()) && + VerifyOffset(verifier, VT_VF64) && + verifier.VerifyVector(vf64()) && + verifier.EndTable(); + } + TypeAliasesT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(TypeAliasesT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct TypeAliasesBuilder { + typedef TypeAliases Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_i8(int8_t i8) { + fbb_.AddElement(TypeAliases::VT_I8, i8, 0); + } + void add_u8(uint8_t u8) { + fbb_.AddElement(TypeAliases::VT_U8, u8, 0); + } + void add_i16(int16_t i16) { + fbb_.AddElement(TypeAliases::VT_I16, i16, 0); + } + void add_u16(uint16_t u16) { + fbb_.AddElement(TypeAliases::VT_U16, u16, 0); + } + void add_i32(int32_t i32) { + fbb_.AddElement(TypeAliases::VT_I32, i32, 0); + } + void add_u32(uint32_t u32) { + fbb_.AddElement(TypeAliases::VT_U32, u32, 0); + } + void add_i64(int64_t i64) { + fbb_.AddElement(TypeAliases::VT_I64, i64, 0); + } + void add_u64(uint64_t u64) { + fbb_.AddElement(TypeAliases::VT_U64, u64, 0); + } + void add_f32(float f32) { + fbb_.AddElement(TypeAliases::VT_F32, f32, 0.0f); + } + void add_f64(double f64) { + fbb_.AddElement(TypeAliases::VT_F64, f64, 0.0); + } + void add_v8(flatbuffers::Offset> v8) { + fbb_.AddOffset(TypeAliases::VT_V8, v8); + } + void add_vf64(flatbuffers::Offset> vf64) { + fbb_.AddOffset(TypeAliases::VT_VF64, vf64); + } + explicit TypeAliasesBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset(end); + return o; + } +}; + +inline flatbuffers::Offset CreateTypeAliases( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + flatbuffers::Offset> v8 = 0, + flatbuffers::Offset> vf64 = 0) { + TypeAliasesBuilder builder_(_fbb); + builder_.add_f64(f64); + builder_.add_u64(u64); + builder_.add_i64(i64); + builder_.add_vf64(vf64); + builder_.add_v8(v8); + builder_.add_f32(f32); + builder_.add_u32(u32); + builder_.add_i32(i32); + builder_.add_u16(u16); + builder_.add_i16(i16); + builder_.add_u8(u8); + builder_.add_i8(i8); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateTypeAliasesDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int8_t i8 = 0, + uint8_t u8 = 0, + int16_t i16 = 0, + uint16_t u16 = 0, + int32_t i32 = 0, + uint32_t u32 = 0, + int64_t i64 = 0, + uint64_t u64 = 0, + float f32 = 0.0f, + double f64 = 0.0, + const std::vector *v8 = nullptr, + const std::vector *vf64 = nullptr) { + auto v8__ = v8 ? _fbb.CreateVector(*v8) : 0; + auto vf64__ = vf64 ? _fbb.CreateVector(*vf64) : 0; + return MyGame::Example::CreateTypeAliases( + _fbb, + i8, + u8, + i16, + u16, + i32, + u32, + i64, + u64, + f32, + f64, + v8__, + vf64__); +} + +flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +} // namespace Example + + +inline bool operator==(const InParentNamespaceT &, const InParentNamespaceT &) { + return true; +} + +inline bool operator!=(const InParentNamespaceT &lhs, const InParentNamespaceT &rhs) { + return !(lhs == rhs); +} + + +inline InParentNamespaceT *InParentNamespace::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new InParentNamespaceT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void InParentNamespace::UnPackTo(InParentNamespaceT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; +} + +inline flatbuffers::Offset InParentNamespace::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateInParentNamespace(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateInParentNamespace(flatbuffers::FlatBufferBuilder &_fbb, const InParentNamespaceT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InParentNamespaceT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return MyGame::CreateInParentNamespace( + _fbb); +} + +namespace Example2 { + + +inline bool operator==(const MonsterT &, const MonsterT &) { + return true; +} + +inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { + return !(lhs == rhs); +} + + +inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new MonsterT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; +} + +inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateMonster(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return MyGame::Example2::CreateMonster( + _fbb); +} + +} // namespace Example2 + +namespace Example { + + +inline bool operator==(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { + return + (lhs.color == rhs.color); +} + +inline bool operator!=(const TestSimpleTableWithEnumT &lhs, const TestSimpleTableWithEnumT &rhs) { + return !(lhs == rhs); +} + + +inline TestSimpleTableWithEnumT *TestSimpleTableWithEnum::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new TestSimpleTableWithEnumT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void TestSimpleTableWithEnum::UnPackTo(TestSimpleTableWithEnumT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = color(); _o->color = _e; } +} + +inline flatbuffers::Offset TestSimpleTableWithEnum::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTestSimpleTableWithEnum(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTestSimpleTableWithEnum(flatbuffers::FlatBufferBuilder &_fbb, const TestSimpleTableWithEnumT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TestSimpleTableWithEnumT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _color = _o->color; + return MyGame::Example::CreateTestSimpleTableWithEnum( + _fbb, + _color); +} + + +inline bool operator==(const StatT &lhs, const StatT &rhs) { + return + (lhs.id == rhs.id) && + (lhs.val == rhs.val) && + (lhs.count == rhs.count); +} + +inline bool operator!=(const StatT &lhs, const StatT &rhs) { + return !(lhs == rhs); +} + + +inline StatT *Stat::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new StatT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Stat::UnPackTo(StatT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); if (_e) _o->id = _e->str(); } + { auto _e = val(); _o->val = _e; } + { auto _e = count(); _o->count = _e; } +} + +inline flatbuffers::Offset Stat::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateStat(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateStat(flatbuffers::FlatBufferBuilder &_fbb, const StatT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id.empty() ? 0 : _fbb.CreateString(_o->id); + auto _val = _o->val; + auto _count = _o->count; + return MyGame::Example::CreateStat( + _fbb, + _id, + _val, + _count); +} + + +inline bool operator==(const ReferrableT &lhs, const ReferrableT &rhs) { + return + (lhs.id == rhs.id); +} + +inline bool operator!=(const ReferrableT &lhs, const ReferrableT &rhs) { + return !(lhs == rhs); +} + + +inline ReferrableT *Referrable::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ReferrableT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Referrable::UnPackTo(ReferrableT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); _o->id = _e; } +} + +inline flatbuffers::Offset Referrable::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateReferrable(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateReferrable(flatbuffers::FlatBufferBuilder &_fbb, const ReferrableT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ReferrableT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id; + return MyGame::Example::CreateReferrable( + _fbb, + _id); +} + + +inline bool operator==(const MonsterT &lhs, const MonsterT &rhs) { + return + ((lhs.pos == rhs.pos) || (lhs.pos && rhs.pos && *lhs.pos == *rhs.pos)) && + (lhs.mana == rhs.mana) && + (lhs.hp == rhs.hp) && + (lhs.name == rhs.name) && + (lhs.inventory == rhs.inventory) && + (lhs.color == rhs.color) && + (lhs.test == rhs.test) && + (lhs.test4 == rhs.test4) && + (lhs.testarrayofstring == rhs.testarrayofstring) && + (lhs.testarrayoftables == rhs.testarrayoftables) && + ((lhs.enemy == rhs.enemy) || (lhs.enemy && rhs.enemy && *lhs.enemy == *rhs.enemy)) && + (lhs.testnestedflatbuffer == rhs.testnestedflatbuffer) && + ((lhs.testempty == rhs.testempty) || (lhs.testempty && rhs.testempty && *lhs.testempty == *rhs.testempty)) && + (lhs.testbool == rhs.testbool) && + (lhs.testhashs32_fnv1 == rhs.testhashs32_fnv1) && + (lhs.testhashu32_fnv1 == rhs.testhashu32_fnv1) && + (lhs.testhashs64_fnv1 == rhs.testhashs64_fnv1) && + (lhs.testhashu64_fnv1 == rhs.testhashu64_fnv1) && + (lhs.testhashs32_fnv1a == rhs.testhashs32_fnv1a) && + (lhs.testhashu32_fnv1a == rhs.testhashu32_fnv1a) && + (lhs.testhashs64_fnv1a == rhs.testhashs64_fnv1a) && + (lhs.testhashu64_fnv1a == rhs.testhashu64_fnv1a) && + (lhs.testarrayofbools == rhs.testarrayofbools) && + (lhs.testf == rhs.testf) && + (lhs.testf2 == rhs.testf2) && + (lhs.testf3 == rhs.testf3) && + (lhs.testarrayofstring2 == rhs.testarrayofstring2) && + (lhs.testarrayofsortedstruct == rhs.testarrayofsortedstruct) && + (lhs.flex == rhs.flex) && + (lhs.test5 == rhs.test5) && + (lhs.vector_of_longs == rhs.vector_of_longs) && + (lhs.vector_of_doubles == rhs.vector_of_doubles) && + ((lhs.parent_namespace_test == rhs.parent_namespace_test) || (lhs.parent_namespace_test && rhs.parent_namespace_test && *lhs.parent_namespace_test == *rhs.parent_namespace_test)) && + (lhs.vector_of_referrables == rhs.vector_of_referrables) && + (lhs.single_weak_reference == rhs.single_weak_reference) && + (lhs.vector_of_weak_references == rhs.vector_of_weak_references) && + (lhs.vector_of_strong_referrables == rhs.vector_of_strong_referrables) && + (lhs.co_owning_reference == rhs.co_owning_reference) && + (lhs.vector_of_co_owning_references == rhs.vector_of_co_owning_references) && + (lhs.non_owning_reference == rhs.non_owning_reference) && + (lhs.vector_of_non_owning_references == rhs.vector_of_non_owning_references) && + (lhs.any_unique == rhs.any_unique) && + (lhs.any_ambiguous == rhs.any_ambiguous) && + (lhs.vector_of_enums == rhs.vector_of_enums) && + (lhs.signed_enum == rhs.signed_enum) && + (lhs.testrequirednestedflatbuffer == rhs.testrequirednestedflatbuffer) && + (lhs.scalar_key_sorted_tables == rhs.scalar_key_sorted_tables) && + (lhs.native_inline == rhs.native_inline) && + (lhs.long_enum_non_enum_default == rhs.long_enum_non_enum_default) && + (lhs.long_enum_normal_default == rhs.long_enum_normal_default); +} + +inline bool operator!=(const MonsterT &lhs, const MonsterT &rhs) { + return !(lhs == rhs); +} + + +inline MonsterT::MonsterT(const MonsterT &o) + : pos((o.pos) ? new MyGame::Example::Vec3(*o.pos) : nullptr), + mana(o.mana), + hp(o.hp), + name(o.name), + inventory(o.inventory), + color(o.color), + test(o.test), + test4(o.test4), + testarrayofstring(o.testarrayofstring), + enemy((o.enemy) ? new MyGame::Example::MonsterT(*o.enemy) : nullptr), + testnestedflatbuffer(o.testnestedflatbuffer), + testempty((o.testempty) ? new MyGame::Example::StatT(*o.testempty) : nullptr), + testbool(o.testbool), + testhashs32_fnv1(o.testhashs32_fnv1), + testhashu32_fnv1(o.testhashu32_fnv1), + testhashs64_fnv1(o.testhashs64_fnv1), + testhashu64_fnv1(o.testhashu64_fnv1), + testhashs32_fnv1a(o.testhashs32_fnv1a), + testhashu32_fnv1a(o.testhashu32_fnv1a), + testhashs64_fnv1a(o.testhashs64_fnv1a), + testhashu64_fnv1a(o.testhashu64_fnv1a), + testarrayofbools(o.testarrayofbools), + testf(o.testf), + testf2(o.testf2), + testf3(o.testf3), + testarrayofstring2(o.testarrayofstring2), + testarrayofsortedstruct(o.testarrayofsortedstruct), + flex(o.flex), + test5(o.test5), + vector_of_longs(o.vector_of_longs), + vector_of_doubles(o.vector_of_doubles), + parent_namespace_test((o.parent_namespace_test) ? new MyGame::InParentNamespaceT(*o.parent_namespace_test) : nullptr), + single_weak_reference(o.single_weak_reference), + vector_of_weak_references(o.vector_of_weak_references), + co_owning_reference(o.co_owning_reference), + non_owning_reference(o.non_owning_reference), + vector_of_non_owning_references(o.vector_of_non_owning_references), + any_unique(o.any_unique), + any_ambiguous(o.any_ambiguous), + vector_of_enums(o.vector_of_enums), + signed_enum(o.signed_enum), + testrequirednestedflatbuffer(o.testrequirednestedflatbuffer), + native_inline(o.native_inline), + long_enum_non_enum_default(o.long_enum_non_enum_default), + long_enum_normal_default(o.long_enum_normal_default) { + testarrayoftables.reserve(o.testarrayoftables.size()); + for (const auto &testarrayoftables_ : o.testarrayoftables) { testarrayoftables.emplace_back((testarrayoftables_) ? new MyGame::Example::MonsterT(*testarrayoftables_) : nullptr); } + vector_of_referrables.reserve(o.vector_of_referrables.size()); + for (const auto &vector_of_referrables_ : o.vector_of_referrables) { vector_of_referrables.emplace_back((vector_of_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_referrables_) : nullptr); } + vector_of_strong_referrables.reserve(o.vector_of_strong_referrables.size()); + for (const auto &vector_of_strong_referrables_ : o.vector_of_strong_referrables) { vector_of_strong_referrables.emplace_back((vector_of_strong_referrables_) ? new MyGame::Example::ReferrableT(*vector_of_strong_referrables_) : nullptr); } + vector_of_co_owning_references.reserve(o.vector_of_co_owning_references.size()); + for (const auto &vector_of_co_owning_references_ : o.vector_of_co_owning_references) { vector_of_co_owning_references.emplace_back((vector_of_co_owning_references_) ? new ReferrableT(*vector_of_co_owning_references_) : nullptr); } + scalar_key_sorted_tables.reserve(o.scalar_key_sorted_tables.size()); + for (const auto &scalar_key_sorted_tables_ : o.scalar_key_sorted_tables) { scalar_key_sorted_tables.emplace_back((scalar_key_sorted_tables_) ? new MyGame::Example::StatT(*scalar_key_sorted_tables_) : nullptr); } +} + +inline MonsterT &MonsterT::operator=(MonsterT o) FLATBUFFERS_NOEXCEPT { + std::swap(pos, o.pos); + std::swap(mana, o.mana); + std::swap(hp, o.hp); + std::swap(name, o.name); + std::swap(inventory, o.inventory); + std::swap(color, o.color); + std::swap(test, o.test); + std::swap(test4, o.test4); + std::swap(testarrayofstring, o.testarrayofstring); + std::swap(testarrayoftables, o.testarrayoftables); + std::swap(enemy, o.enemy); + std::swap(testnestedflatbuffer, o.testnestedflatbuffer); + std::swap(testempty, o.testempty); + std::swap(testbool, o.testbool); + std::swap(testhashs32_fnv1, o.testhashs32_fnv1); + std::swap(testhashu32_fnv1, o.testhashu32_fnv1); + std::swap(testhashs64_fnv1, o.testhashs64_fnv1); + std::swap(testhashu64_fnv1, o.testhashu64_fnv1); + std::swap(testhashs32_fnv1a, o.testhashs32_fnv1a); + std::swap(testhashu32_fnv1a, o.testhashu32_fnv1a); + std::swap(testhashs64_fnv1a, o.testhashs64_fnv1a); + std::swap(testhashu64_fnv1a, o.testhashu64_fnv1a); + std::swap(testarrayofbools, o.testarrayofbools); + std::swap(testf, o.testf); + std::swap(testf2, o.testf2); + std::swap(testf3, o.testf3); + std::swap(testarrayofstring2, o.testarrayofstring2); + std::swap(testarrayofsortedstruct, o.testarrayofsortedstruct); + std::swap(flex, o.flex); + std::swap(test5, o.test5); + std::swap(vector_of_longs, o.vector_of_longs); + std::swap(vector_of_doubles, o.vector_of_doubles); + std::swap(parent_namespace_test, o.parent_namespace_test); + std::swap(vector_of_referrables, o.vector_of_referrables); + std::swap(single_weak_reference, o.single_weak_reference); + std::swap(vector_of_weak_references, o.vector_of_weak_references); + std::swap(vector_of_strong_referrables, o.vector_of_strong_referrables); + std::swap(co_owning_reference, o.co_owning_reference); + std::swap(vector_of_co_owning_references, o.vector_of_co_owning_references); + std::swap(non_owning_reference, o.non_owning_reference); + std::swap(vector_of_non_owning_references, o.vector_of_non_owning_references); + std::swap(any_unique, o.any_unique); + std::swap(any_ambiguous, o.any_ambiguous); + std::swap(vector_of_enums, o.vector_of_enums); + std::swap(signed_enum, o.signed_enum); + std::swap(testrequirednestedflatbuffer, o.testrequirednestedflatbuffer); + std::swap(scalar_key_sorted_tables, o.scalar_key_sorted_tables); + std::swap(native_inline, o.native_inline); + std::swap(long_enum_non_enum_default, o.long_enum_non_enum_default); + std::swap(long_enum_normal_default, o.long_enum_normal_default); + return *this; +} + +inline MonsterT *Monster::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new MonsterT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void Monster::UnPackTo(MonsterT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = pos(); if (_e) _o->pos = flatbuffers::unique_ptr(new MyGame::Example::Vec3(*_e)); } + { auto _e = mana(); _o->mana = _e; } + { auto _e = hp(); _o->hp = _e; } + { auto _e = name(); if (_e) _o->name = _e->str(); } + { auto _e = inventory(); if (_e) { _o->inventory.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->inventory.begin()); } } + { auto _e = color(); _o->color = _e; } + { auto _e = test_type(); _o->test.type = _e; } + { auto _e = test(); if (_e) _o->test.value = MyGame::Example::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++) { if(_o->testarrayoftables[_i]) { _e->Get(_i)->UnPackTo(_o->testarrayoftables[_i].get(), _resolver); } else { _o->testarrayoftables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = enemy(); if (_e) { if(_o->enemy) { _e->UnPackTo(_o->enemy.get(), _resolver); } else { _o->enemy = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = testnestedflatbuffer(); if (_e) { _o->testnestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testnestedflatbuffer.begin()); } } + { auto _e = testempty(); if (_e) { if(_o->testempty) { _e->UnPackTo(_o->testempty.get(), _resolver); } else { _o->testempty = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = testbool(); _o->testbool = _e; } + { auto _e = testhashs32_fnv1(); _o->testhashs32_fnv1 = _e; } + { auto _e = testhashu32_fnv1(); _o->testhashu32_fnv1 = _e; } + { auto _e = testhashs64_fnv1(); _o->testhashs64_fnv1 = _e; } + { auto _e = testhashu64_fnv1(); _o->testhashu64_fnv1 = _e; } + { auto _e = testhashs32_fnv1a(); _o->testhashs32_fnv1a = _e; } + { auto _e = testhashu32_fnv1a(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->testhashu32_fnv1a), static_cast(_e)); else _o->testhashu32_fnv1a = nullptr; } + { auto _e = testhashs64_fnv1a(); _o->testhashs64_fnv1a = _e; } + { auto _e = testhashu64_fnv1a(); _o->testhashu64_fnv1a = _e; } + { auto _e = testarrayofbools(); if (_e) { _o->testarrayofbools.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofbools[_i] = _e->Get(_i) != 0; } } } + { auto _e = testf(); _o->testf = _e; } + { auto _e = testf2(); _o->testf2 = _e; } + { auto _e = testf3(); _o->testf3 = _e; } + { auto _e = testarrayofstring2(); if (_e) { _o->testarrayofstring2.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofstring2[_i] = _e->Get(_i)->str(); } } } + { auto _e = testarrayofsortedstruct(); if (_e) { _o->testarrayofsortedstruct.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->testarrayofsortedstruct[_i] = *_e->Get(_i); } } } + { auto _e = flex(); if (_e) { _o->flex.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->flex.begin()); } } + { auto _e = test5(); if (_e) { _o->test5.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->test5[_i] = *_e->Get(_i); } } } + { auto _e = vector_of_longs(); if (_e) { _o->vector_of_longs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_longs[_i] = _e->Get(_i); } } } + { auto _e = vector_of_doubles(); if (_e) { _o->vector_of_doubles.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_doubles[_i] = _e->Get(_i); } } } + { auto _e = parent_namespace_test(); if (_e) { if(_o->parent_namespace_test) { _e->UnPackTo(_o->parent_namespace_test.get(), _resolver); } else { _o->parent_namespace_test = flatbuffers::unique_ptr(_e->UnPack(_resolver)); } } } + { auto _e = vector_of_referrables(); if (_e) { _o->vector_of_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_referrables[_i].get(), _resolver); } else { _o->vector_of_referrables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = single_weak_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->single_weak_reference), static_cast(_e)); else _o->single_weak_reference = nullptr; } + { auto _e = vector_of_weak_references(); if (_e) { _o->vector_of_weak_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_weak_references[_i]), static_cast(_e->Get(_i))); else _o->vector_of_weak_references[_i] = nullptr; } } } + { auto _e = vector_of_strong_referrables(); if (_e) { _o->vector_of_strong_referrables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->vector_of_strong_referrables[_i]) { _e->Get(_i)->UnPackTo(_o->vector_of_strong_referrables[_i].get(), _resolver); } else { _o->vector_of_strong_referrables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = co_owning_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->co_owning_reference), static_cast(_e)); else _o->co_owning_reference = nullptr; } + { auto _e = vector_of_co_owning_references(); if (_e) { _o->vector_of_co_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, default_ptr_type +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_co_owning_references[_i]), static_cast(_e->Get(_i)));/* else do nothing */; } } } + { auto _e = non_owning_reference(); //scalar resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->non_owning_reference), static_cast(_e)); else _o->non_owning_reference = nullptr; } + { auto _e = vector_of_non_owning_references(); if (_e) { _o->vector_of_non_owning_references.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { //vector resolver, naked +if (_resolver) (*_resolver)(reinterpret_cast(&_o->vector_of_non_owning_references[_i]), static_cast(_e->Get(_i))); else _o->vector_of_non_owning_references[_i] = nullptr; } } } + { auto _e = any_unique_type(); _o->any_unique.type = _e; } + { auto _e = any_unique(); if (_e) _o->any_unique.value = MyGame::Example::AnyUniqueAliasesUnion::UnPack(_e, any_unique_type(), _resolver); } + { auto _e = any_ambiguous_type(); _o->any_ambiguous.type = _e; } + { auto _e = any_ambiguous(); if (_e) _o->any_ambiguous.value = MyGame::Example::AnyAmbiguousAliasesUnion::UnPack(_e, any_ambiguous_type(), _resolver); } + { auto _e = vector_of_enums(); if (_e) { _o->vector_of_enums.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vector_of_enums[_i] = static_cast(_e->Get(_i)); } } } + { auto _e = signed_enum(); _o->signed_enum = _e; } + { auto _e = testrequirednestedflatbuffer(); if (_e) { _o->testrequirednestedflatbuffer.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->testrequirednestedflatbuffer.begin()); } } + { auto _e = scalar_key_sorted_tables(); if (_e) { _o->scalar_key_sorted_tables.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->scalar_key_sorted_tables[_i]) { _e->Get(_i)->UnPackTo(_o->scalar_key_sorted_tables[_i].get(), _resolver); } else { _o->scalar_key_sorted_tables[_i] = flatbuffers::unique_ptr(_e->Get(_i)->UnPack(_resolver)); }; } } } + { auto _e = native_inline(); if (_e) _o->native_inline = *_e; } + { auto _e = long_enum_non_enum_default(); _o->long_enum_non_enum_default = _e; } + { auto _e = long_enum_normal_default(); _o->long_enum_normal_default = _e; } +} + +inline flatbuffers::Offset Monster::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateMonster(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateMonster(flatbuffers::FlatBufferBuilder &_fbb, const MonsterT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const MonsterT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _pos = _o->pos ? _o->pos.get() : 0; + auto _mana = _o->mana; + auto _hp = _o->hp; + auto _name = _fbb.CreateString(_o->name); + auto _inventory = _o->inventory.size() ? _fbb.CreateVector(_o->inventory) : 0; + auto _color = _o->color; + auto _test_type = _o->test.type; + auto _test = _o->test.Pack(_fbb); + auto _test4 = _o->test4.size() ? _fbb.CreateVectorOfStructs(_o->test4) : 0; + auto _testarrayofstring = _o->testarrayofstring.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring) : 0; + auto _testarrayoftables = _o->testarrayoftables.size() ? _fbb.CreateVector> (_o->testarrayoftables.size(), [](size_t i, _VectorArgs *__va) { return CreateMonster(*__va->__fbb, __va->__o->testarrayoftables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _enemy = _o->enemy ? CreateMonster(_fbb, _o->enemy.get(), _rehasher) : 0; + auto _testnestedflatbuffer = _o->testnestedflatbuffer.size() ? _fbb.CreateVector(_o->testnestedflatbuffer) : 0; + auto _testempty = _o->testempty ? CreateStat(_fbb, _o->testempty.get(), _rehasher) : 0; + auto _testbool = _o->testbool; + auto _testhashs32_fnv1 = _o->testhashs32_fnv1; + auto _testhashu32_fnv1 = _o->testhashu32_fnv1; + auto _testhashs64_fnv1 = _o->testhashs64_fnv1; + auto _testhashu64_fnv1 = _o->testhashu64_fnv1; + auto _testhashs32_fnv1a = _o->testhashs32_fnv1a; + auto _testhashu32_fnv1a = _rehasher ? static_cast((*_rehasher)(_o->testhashu32_fnv1a)) : 0; + auto _testhashs64_fnv1a = _o->testhashs64_fnv1a; + auto _testhashu64_fnv1a = _o->testhashu64_fnv1a; + auto _testarrayofbools = _o->testarrayofbools.size() ? _fbb.CreateVector(_o->testarrayofbools) : 0; + auto _testf = _o->testf; + auto _testf2 = _o->testf2; + auto _testf3 = _o->testf3; + auto _testarrayofstring2 = _o->testarrayofstring2.size() ? _fbb.CreateVectorOfStrings(_o->testarrayofstring2) : 0; + auto _testarrayofsortedstruct = _o->testarrayofsortedstruct.size() ? _fbb.CreateVectorOfStructs(_o->testarrayofsortedstruct) : 0; + auto _flex = _o->flex.size() ? _fbb.CreateVector(_o->flex) : 0; + auto _test5 = _o->test5.size() ? _fbb.CreateVectorOfStructs(_o->test5) : 0; + auto _vector_of_longs = _o->vector_of_longs.size() ? _fbb.CreateVector(_o->vector_of_longs) : 0; + auto _vector_of_doubles = _o->vector_of_doubles.size() ? _fbb.CreateVector(_o->vector_of_doubles) : 0; + auto _parent_namespace_test = _o->parent_namespace_test ? CreateInParentNamespace(_fbb, _o->parent_namespace_test.get(), _rehasher) : 0; + auto _vector_of_referrables = _o->vector_of_referrables.size() ? _fbb.CreateVector> (_o->vector_of_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _single_weak_reference = _rehasher ? static_cast((*_rehasher)(_o->single_weak_reference)) : 0; + auto _vector_of_weak_references = _o->vector_of_weak_references.size() ? _fbb.CreateVector(_o->vector_of_weak_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_weak_references[i])) : 0; }, &_va ) : 0; + auto _vector_of_strong_referrables = _o->vector_of_strong_referrables.size() ? _fbb.CreateVector> (_o->vector_of_strong_referrables.size(), [](size_t i, _VectorArgs *__va) { return CreateReferrable(*__va->__fbb, __va->__o->vector_of_strong_referrables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _co_owning_reference = _rehasher ? static_cast((*_rehasher)(_o->co_owning_reference)) : 0; + auto _vector_of_co_owning_references = _o->vector_of_co_owning_references.size() ? _fbb.CreateVector(_o->vector_of_co_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_co_owning_references[i].get())) : 0; }, &_va ) : 0; + auto _non_owning_reference = _rehasher ? static_cast((*_rehasher)(_o->non_owning_reference)) : 0; + auto _vector_of_non_owning_references = _o->vector_of_non_owning_references.size() ? _fbb.CreateVector(_o->vector_of_non_owning_references.size(), [](size_t i, _VectorArgs *__va) { return __va->__rehasher ? static_cast((*__va->__rehasher)(__va->__o->vector_of_non_owning_references[i])) : 0; }, &_va ) : 0; + auto _any_unique_type = _o->any_unique.type; + auto _any_unique = _o->any_unique.Pack(_fbb); + auto _any_ambiguous_type = _o->any_ambiguous.type; + auto _any_ambiguous = _o->any_ambiguous.Pack(_fbb); + auto _vector_of_enums = _o->vector_of_enums.size() ? _fbb.CreateVectorScalarCast(flatbuffers::data(_o->vector_of_enums), _o->vector_of_enums.size()) : 0; + auto _signed_enum = _o->signed_enum; + auto _testrequirednestedflatbuffer = _o->testrequirednestedflatbuffer.size() ? _fbb.CreateVector(_o->testrequirednestedflatbuffer) : 0; + auto _scalar_key_sorted_tables = _o->scalar_key_sorted_tables.size() ? _fbb.CreateVector> (_o->scalar_key_sorted_tables.size(), [](size_t i, _VectorArgs *__va) { return CreateStat(*__va->__fbb, __va->__o->scalar_key_sorted_tables[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _native_inline = &_o->native_inline; + auto _long_enum_non_enum_default = _o->long_enum_non_enum_default; + auto _long_enum_normal_default = _o->long_enum_normal_default; + return MyGame::Example::CreateMonster( + _fbb, + _pos, + _mana, + _hp, + _name, + _inventory, + _color, + _test_type, + _test, + _test4, + _testarrayofstring, + _testarrayoftables, + _enemy, + _testnestedflatbuffer, + _testempty, + _testbool, + _testhashs32_fnv1, + _testhashu32_fnv1, + _testhashs64_fnv1, + _testhashu64_fnv1, + _testhashs32_fnv1a, + _testhashu32_fnv1a, + _testhashs64_fnv1a, + _testhashu64_fnv1a, + _testarrayofbools, + _testf, + _testf2, + _testf3, + _testarrayofstring2, + _testarrayofsortedstruct, + _flex, + _test5, + _vector_of_longs, + _vector_of_doubles, + _parent_namespace_test, + _vector_of_referrables, + _single_weak_reference, + _vector_of_weak_references, + _vector_of_strong_referrables, + _co_owning_reference, + _vector_of_co_owning_references, + _non_owning_reference, + _vector_of_non_owning_references, + _any_unique_type, + _any_unique, + _any_ambiguous_type, + _any_ambiguous, + _vector_of_enums, + _signed_enum, + _testrequirednestedflatbuffer, + _scalar_key_sorted_tables, + _native_inline, + _long_enum_non_enum_default, + _long_enum_normal_default); +} + + +inline bool operator==(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { + return + (lhs.i8 == rhs.i8) && + (lhs.u8 == rhs.u8) && + (lhs.i16 == rhs.i16) && + (lhs.u16 == rhs.u16) && + (lhs.i32 == rhs.i32) && + (lhs.u32 == rhs.u32) && + (lhs.i64 == rhs.i64) && + (lhs.u64 == rhs.u64) && + (lhs.f32 == rhs.f32) && + (lhs.f64 == rhs.f64) && + (lhs.v8 == rhs.v8) && + (lhs.vf64 == rhs.vf64); +} + +inline bool operator!=(const TypeAliasesT &lhs, const TypeAliasesT &rhs) { + return !(lhs == rhs); +} + + +inline TypeAliasesT *TypeAliases::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new TypeAliasesT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +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()); std::copy(_e->begin(), _e->end(), _o->v8.begin()); } } + { auto _e = vf64(); if (_e) { _o->vf64.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vf64[_i] = _e->Get(_i); } } } +} + +inline flatbuffers::Offset TypeAliases::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateTypeAliases(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateTypeAliases(flatbuffers::FlatBufferBuilder &_fbb, const TypeAliasesT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const TypeAliasesT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _i8 = _o->i8; + auto _u8 = _o->u8; + auto _i16 = _o->i16; + auto _u16 = _o->u16; + auto _i32 = _o->i32; + auto _u32 = _o->u32; + auto _i64 = _o->i64; + auto _u64 = _o->u64; + auto _f32 = _o->f32; + auto _f64 = _o->f64; + auto _v8 = _o->v8.size() ? _fbb.CreateVector(_o->v8) : 0; + auto _vf64 = _o->vf64.size() ? _fbb.CreateVector(_o->vf64) : 0; + return MyGame::Example::CreateTypeAliases( + _fbb, + _i8, + _u8, + _i16, + _u16, + _i32, + _u32, + _i64, + _u64, + _f32, + _f64, + _v8, + _vf64); +} + +inline bool VerifyAny(flatbuffers::Verifier &verifier, const void *obj, Any type) { + switch (type) { + case Any_NONE: { + return true; + } + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAny( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyUnion::UnPack(const void *obj, Any type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(value); + return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyUnion::AnyUnion(const AnyUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case Any_Monster: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case Any_TestSimpleTableWithEnum: { + value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast(u.value)); + break; + } + case Any_MyGame_Example2_Monster: { + value = new MyGame::Example2::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyUnion::Reset() { + switch (type) { + case Any_Monster: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Any_TestSimpleTableWithEnum: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Any_MyGame_Example2_Monster: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = Any_NONE; +} + +inline bool VerifyAnyUniqueAliases(flatbuffers::Verifier &verifier, const void *obj, AnyUniqueAliases type) { + switch (type) { + case AnyUniqueAliases_NONE: { + return true; + } + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyUniqueAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAnyUniqueAliases( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyUniqueAliasesUnion::UnPack(const void *obj, AnyUniqueAliases type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyUniqueAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(value); + return CreateTestSimpleTableWithEnum(_fbb, ptr, _rehasher).Union(); + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyUniqueAliasesUnion::AnyUniqueAliasesUnion(const AnyUniqueAliasesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case AnyUniqueAliases_M: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyUniqueAliases_TS: { + value = new MyGame::Example::TestSimpleTableWithEnumT(*reinterpret_cast(u.value)); + break; + } + case AnyUniqueAliases_M2: { + value = new MyGame::Example2::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyUniqueAliasesUnion::Reset() { + switch (type) { + case AnyUniqueAliases_M: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyUniqueAliases_TS: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyUniqueAliases_M2: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = AnyUniqueAliases_NONE; +} + +inline bool VerifyAnyAmbiguousAliases(flatbuffers::Verifier &verifier, const void *obj, AnyAmbiguousAliases type) { + switch (type) { + case AnyAmbiguousAliases_NONE: { + return true; + } + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAnyAmbiguousAliasesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAnyAmbiguousAliases( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *AnyAmbiguousAliasesUnion::UnPack(const void *obj, AnyAmbiguousAliases type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset AnyAmbiguousAliasesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(value); + return CreateMonster(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline AnyAmbiguousAliasesUnion::AnyAmbiguousAliasesUnion(const AnyAmbiguousAliasesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case AnyAmbiguousAliases_M1: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyAmbiguousAliases_M2: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + case AnyAmbiguousAliases_M3: { + value = new MyGame::Example::MonsterT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void AnyAmbiguousAliasesUnion::Reset() { + switch (type) { + case AnyAmbiguousAliases_M1: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyAmbiguousAliases_M2: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case AnyAmbiguousAliases_M3: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = AnyAmbiguousAliases_NONE; +} + +inline const flatbuffers::TypeTable *ColorTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_UCHAR, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable + }; + static const int64_t values[] = { 1, 2, 8 }; + static const char * const names[] = { + "Red", + "Green", + "Blue" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *RaceTypeTable() { + 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 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::RaceTypeTable + }; + static const int64_t values[] = { -1, 0, 1, 2 }; + static const char * const names[] = { + "None", + "Human", + "Dwarf", + "Elf" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *LongEnumTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_ULONG, 0, 0 }, + { flatbuffers::ET_ULONG, 0, 0 }, + { flatbuffers::ET_ULONG, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::LongEnumTypeTable + }; + static const int64_t values[] = { 2ULL, 4ULL, 1099511627776ULL }; + static const char * const names[] = { + "LongOne", + "LongTwo", + "LongBig" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_ENUM, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 2 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable, + MyGame::Example::TestSimpleTableWithEnumTypeTable, + MyGame::Example2::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "Monster", + "TestSimpleTableWithEnum", + "MyGame_Example2_Monster" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyUniqueAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 2 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable, + MyGame::Example::TestSimpleTableWithEnumTypeTable, + MyGame::Example2::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "M", + "TS", + "M2" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AnyAmbiguousAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::MonsterTypeTable + }; + static const char * const names[] = { + "NONE", + "M1", + "M2", + "M3" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_UNION, 4, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +} // namespace Example + +inline const flatbuffers::TypeTable *InParentNamespaceTypeTable() { + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr + }; + return &tt; +} + +namespace Example2 { + +inline const flatbuffers::TypeTable *MonsterTypeTable() { + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr + }; + return &tt; +} + +} // namespace Example2 + +namespace Example { + +inline const flatbuffers::TypeTable *TestTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_CHAR, 0, -1 } + }; + static const int64_t values[] = { 0, 2, 4 }; + static const char * const names[] = { + "a", + "b" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *TestSimpleTableWithEnumTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UCHAR, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable + }; + static const char * const names[] = { + "color" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *Vec3TypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_DOUBLE, 0, -1 }, + { flatbuffers::ET_UCHAR, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::ColorTypeTable, + MyGame::Example::TestTypeTable + }; + static const int64_t values[] = { 0, 4, 8, 16, 24, 26, 32 }; + static const char * const names[] = { + "x", + "y", + "z", + "test1", + "test2", + "test3" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 6, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *AbilityTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 } + }; + static const int64_t values[] = { 0, 4, 8 }; + static const char * const names[] = { + "id", + "distance" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 2, type_codes, nullptr, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StructOfStructsTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SEQUENCE, 0, 1 }, + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::AbilityTypeTable, + MyGame::Example::TestTypeTable + }; + static const int64_t values[] = { 0, 8, 12, 20 }; + static const char * const names[] = { + "a", + "b", + "c" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 3, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StructOfStructsOfStructsTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::StructOfStructsTypeTable + }; + static const int64_t values[] = { 0, 20 }; + static const char * const names[] = { + "a" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_STRUCT, 1, type_codes, type_refs, nullptr, values, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *StatTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_STRING, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_USHORT, 0, -1 } + }; + static const char * const names[] = { + "id", + "val", + "count" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 3, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *ReferrableTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_ULONG, 0, -1 } + }; + static const char * const names[] = { + "id" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *MonsterTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_SEQUENCE, 0, 0 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_STRING, 0, -1 }, + { flatbuffers::ET_BOOL, 0, -1 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_UCHAR, 0, 1 }, + { flatbuffers::ET_UTYPE, 0, 2 }, + { flatbuffers::ET_SEQUENCE, 0, 2 }, + { flatbuffers::ET_SEQUENCE, 1, 3 }, + { flatbuffers::ET_STRING, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 4 }, + { flatbuffers::ET_SEQUENCE, 0, 4 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 5 }, + { flatbuffers::ET_BOOL, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_BOOL, 1, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_STRING, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 6 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 3 }, + { flatbuffers::ET_LONG, 1, -1 }, + { flatbuffers::ET_DOUBLE, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 0, 7 }, + { flatbuffers::ET_SEQUENCE, 1, 8 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 8 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_ULONG, 1, -1 }, + { flatbuffers::ET_UTYPE, 0, 9 }, + { flatbuffers::ET_SEQUENCE, 0, 9 }, + { flatbuffers::ET_UTYPE, 0, 10 }, + { flatbuffers::ET_SEQUENCE, 0, 10 }, + { flatbuffers::ET_UCHAR, 1, 1 }, + { flatbuffers::ET_CHAR, 0, 11 }, + { flatbuffers::ET_UCHAR, 1, -1 }, + { flatbuffers::ET_SEQUENCE, 1, 5 }, + { flatbuffers::ET_SEQUENCE, 0, 3 }, + { flatbuffers::ET_ULONG, 0, 12 }, + { flatbuffers::ET_ULONG, 0, 12 } + }; + static const flatbuffers::TypeFunction type_refs[] = { + MyGame::Example::Vec3TypeTable, + MyGame::Example::ColorTypeTable, + MyGame::Example::AnyTypeTable, + MyGame::Example::TestTypeTable, + MyGame::Example::MonsterTypeTable, + MyGame::Example::StatTypeTable, + MyGame::Example::AbilityTypeTable, + MyGame::InParentNamespaceTypeTable, + MyGame::Example::ReferrableTypeTable, + MyGame::Example::AnyUniqueAliasesTypeTable, + MyGame::Example::AnyAmbiguousAliasesTypeTable, + MyGame::Example::RaceTypeTable, + MyGame::Example::LongEnumTypeTable + }; + static const char * const names[] = { + "pos", + "mana", + "hp", + "name", + "friendly", + "inventory", + "color", + "test_type", + "test", + "test4", + "testarrayofstring", + "testarrayoftables", + "enemy", + "testnestedflatbuffer", + "testempty", + "testbool", + "testhashs32_fnv1", + "testhashu32_fnv1", + "testhashs64_fnv1", + "testhashu64_fnv1", + "testhashs32_fnv1a", + "testhashu32_fnv1a", + "testhashs64_fnv1a", + "testhashu64_fnv1a", + "testarrayofbools", + "testf", + "testf2", + "testf3", + "testarrayofstring2", + "testarrayofsortedstruct", + "flex", + "test5", + "vector_of_longs", + "vector_of_doubles", + "parent_namespace_test", + "vector_of_referrables", + "single_weak_reference", + "vector_of_weak_references", + "vector_of_strong_referrables", + "co_owning_reference", + "vector_of_co_owning_references", + "non_owning_reference", + "vector_of_non_owning_references", + "any_unique_type", + "any_unique", + "any_ambiguous_type", + "any_ambiguous", + "vector_of_enums", + "signed_enum", + "testrequirednestedflatbuffer", + "scalar_key_sorted_tables", + "native_inline", + "long_enum_non_enum_default", + "long_enum_normal_default" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 54, type_codes, type_refs, nullptr, nullptr, names + }; + return &tt; +} + +inline const flatbuffers::TypeTable *TypeAliasesTypeTable() { + static const flatbuffers::TypeCode type_codes[] = { + { flatbuffers::ET_CHAR, 0, -1 }, + { flatbuffers::ET_UCHAR, 0, -1 }, + { flatbuffers::ET_SHORT, 0, -1 }, + { flatbuffers::ET_USHORT, 0, -1 }, + { flatbuffers::ET_INT, 0, -1 }, + { flatbuffers::ET_UINT, 0, -1 }, + { flatbuffers::ET_LONG, 0, -1 }, + { flatbuffers::ET_ULONG, 0, -1 }, + { flatbuffers::ET_FLOAT, 0, -1 }, + { flatbuffers::ET_DOUBLE, 0, -1 }, + { flatbuffers::ET_CHAR, 1, -1 }, + { flatbuffers::ET_DOUBLE, 1, -1 } + }; + static const char * const names[] = { + "i8", + "u8", + "i16", + "u16", + "i32", + "u32", + "i64", + "u64", + "f32", + "f64", + "v8", + "vf64" + }; + static const flatbuffers::TypeTable tt = { + flatbuffers::ST_TABLE, 12, type_codes, nullptr, nullptr, nullptr, names + }; + return &tt; +} + +inline const MyGame::Example::Monster *GetMonster(const void *buf) { + return flatbuffers::GetRoot(buf); +} + +inline const MyGame::Example::Monster *GetSizePrefixedMonster(const void *buf) { + return flatbuffers::GetSizePrefixedRoot(buf); +} + +inline Monster *GetMutableMonster(void *buf) { + return flatbuffers::GetMutableRoot(buf); +} + +inline MyGame::Example::Monster *GetMutableSizePrefixedMonster(void *buf) { + return flatbuffers::GetMutableSizePrefixedRoot(buf); +} + +inline const char *MonsterIdentifier() { + return "MONS"; +} + +inline bool MonsterBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, MonsterIdentifier()); +} + +inline bool SizePrefixedMonsterBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, MonsterIdentifier(), true); +} + +inline bool VerifyMonsterBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer(MonsterIdentifier()); +} + +inline bool VerifySizePrefixedMonsterBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer(MonsterIdentifier()); +} + +inline const char *MonsterExtension() { + return "mon"; +} + +inline void FinishMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.Finish(root, MonsterIdentifier()); +} + +inline void FinishSizePrefixedMonsterBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset root) { + fbb.FinishSizePrefixed(root, MonsterIdentifier()); +} + +inline flatbuffers::unique_ptr UnPackMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr(GetMonster(buf)->UnPack(res)); +} + +inline flatbuffers::unique_ptr UnPackSizePrefixedMonster( + const void *buf, + const flatbuffers::resolver_function_t *res = nullptr) { + return flatbuffers::unique_ptr(GetSizePrefixedMonster(buf)->UnPack(res)); +} + +} // namespace Example +} // namespace MyGame + +#endif // FLATBUFFERS_GENERATED_MONSTERTEST_MYGAME_EXAMPLE_H_