From a3ce1723b2f8f690652d181a96344ab9b1c438a4 Mon Sep 17 00:00:00 2001 From: Dmitry Vyukov Date: Thu, 2 May 2024 08:12:10 +0200 Subject: pkg/flatrpc: add schema Add schema for manager<->fuzzer communication. We may need to change things when we start to use this, but this serves as a proof of concept that we can express things that we need in flatbuffers. --- pkg/flatrpc/flatrpc.h | 2835 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2835 insertions(+) create mode 100644 pkg/flatrpc/flatrpc.h (limited to 'pkg/flatrpc/flatrpc.h') diff --git a/pkg/flatrpc/flatrpc.h b/pkg/flatrpc/flatrpc.h new file mode 100644 index 000000000..37746bbf2 --- /dev/null +++ b/pkg/flatrpc/flatrpc.h @@ -0,0 +1,2835 @@ +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_FLATRPC_RPC_H_ +#define FLATBUFFERS_GENERATED_FLATRPC_RPC_H_ + +#include "flatbuffers/flatbuffers.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 == 8, + "Non-compatible flatbuffers version included"); + +namespace rpc { + +struct ConnectRequest; +struct ConnectRequestBuilder; +struct ConnectRequestT; + +struct ConnectReply; +struct ConnectReplyBuilder; +struct ConnectReplyT; + +struct InfoRequest; +struct InfoRequestBuilder; +struct InfoRequestT; + +struct InfoReply; +struct InfoReplyBuilder; +struct InfoReplyT; + +struct FileInfo; +struct FileInfoBuilder; +struct FileInfoT; + +struct GlobInfo; +struct GlobInfoBuilder; +struct GlobInfoT; + +struct HostMessage; +struct HostMessageBuilder; +struct HostMessageT; + +struct ExecutorMessage; +struct ExecutorMessageBuilder; +struct ExecutorMessageT; + +struct ExecRequest; +struct ExecRequestBuilder; +struct ExecRequestT; + +struct SignalUpdate; +struct SignalUpdateBuilder; +struct SignalUpdateT; + +struct ExecutingMessage; +struct ExecutingMessageBuilder; +struct ExecutingMessageT; + +struct StatsMessage; +struct StatsMessageBuilder; +struct StatsMessageT; + +struct CallInfo; +struct CallInfoBuilder; +struct CallInfoT; + +struct Comparison; + +struct ProgInfo; +struct ProgInfoBuilder; +struct ProgInfoT; + +struct ExecResult; +struct ExecResultBuilder; +struct ExecResultT; + +enum class Feature : uint64_t { + Coverage = 1ULL, + Comparisons = 2ULL, + ExtraCoverage = 4ULL, + DelayKcovMmap = 8ULL, + SandboxSetuid = 16ULL, + SandboxNamespace = 32ULL, + SandboxAndroid = 64ULL, + Fault = 128ULL, + Leak = 256ULL, + NetInjection = 512ULL, + NetDevices = 1024ULL, + KCSAN = 2048ULL, + DevlinkPCI = 4096ULL, + NicVF = 8192ULL, + USBEmulation = 16384ULL, + VhciInjection = 32768ULL, + WifiEmulation = 65536ULL, + LRWPANEmulation = 131072ULL, + BinFmtMisc = 262144ULL, + Swap = 524288ULL, + NONE = 0, + ANY = 1048575ULL +}; +FLATBUFFERS_DEFINE_BITMASK_OPERATORS(Feature, uint64_t) + +inline const Feature (&EnumValuesFeature())[20] { + static const Feature values[] = { + Feature::Coverage, + Feature::Comparisons, + Feature::ExtraCoverage, + Feature::DelayKcovMmap, + Feature::SandboxSetuid, + Feature::SandboxNamespace, + Feature::SandboxAndroid, + Feature::Fault, + Feature::Leak, + Feature::NetInjection, + Feature::NetDevices, + Feature::KCSAN, + Feature::DevlinkPCI, + Feature::NicVF, + Feature::USBEmulation, + Feature::VhciInjection, + Feature::WifiEmulation, + Feature::LRWPANEmulation, + Feature::BinFmtMisc, + Feature::Swap + }; + return values; +} + +inline const char *EnumNameFeature(Feature e) { + switch (e) { + case Feature::Coverage: return "Coverage"; + case Feature::Comparisons: return "Comparisons"; + case Feature::ExtraCoverage: return "ExtraCoverage"; + case Feature::DelayKcovMmap: return "DelayKcovMmap"; + case Feature::SandboxSetuid: return "SandboxSetuid"; + case Feature::SandboxNamespace: return "SandboxNamespace"; + case Feature::SandboxAndroid: return "SandboxAndroid"; + case Feature::Fault: return "Fault"; + case Feature::Leak: return "Leak"; + case Feature::NetInjection: return "NetInjection"; + case Feature::NetDevices: return "NetDevices"; + case Feature::KCSAN: return "KCSAN"; + case Feature::DevlinkPCI: return "DevlinkPCI"; + case Feature::NicVF: return "NicVF"; + case Feature::USBEmulation: return "USBEmulation"; + case Feature::VhciInjection: return "VhciInjection"; + case Feature::WifiEmulation: return "WifiEmulation"; + case Feature::LRWPANEmulation: return "LRWPANEmulation"; + case Feature::BinFmtMisc: return "BinFmtMisc"; + case Feature::Swap: return "Swap"; + default: return ""; + } +} + +enum class HostMessages : uint8_t { + NONE = 0, + ExecRequest = 1, + SignalUpdate = 2, + MIN = NONE, + MAX = SignalUpdate +}; + +inline const HostMessages (&EnumValuesHostMessages())[3] { + static const HostMessages values[] = { + HostMessages::NONE, + HostMessages::ExecRequest, + HostMessages::SignalUpdate + }; + return values; +} + +inline const char * const *EnumNamesHostMessages() { + static const char * const names[4] = { + "NONE", + "ExecRequest", + "SignalUpdate", + nullptr + }; + return names; +} + +inline const char *EnumNameHostMessages(HostMessages e) { + if (flatbuffers::IsOutRange(e, HostMessages::NONE, HostMessages::SignalUpdate)) return ""; + const size_t index = static_cast(e); + return EnumNamesHostMessages()[index]; +} + +template struct HostMessagesTraits { + static const HostMessages enum_value = HostMessages::NONE; +}; + +template<> struct HostMessagesTraits { + static const HostMessages enum_value = HostMessages::ExecRequest; +}; + +template<> struct HostMessagesTraits { + static const HostMessages enum_value = HostMessages::SignalUpdate; +}; + +template struct HostMessagesUnionTraits { + static const HostMessages enum_value = HostMessages::NONE; +}; + +template<> struct HostMessagesUnionTraits { + static const HostMessages enum_value = HostMessages::ExecRequest; +}; + +template<> struct HostMessagesUnionTraits { + static const HostMessages enum_value = HostMessages::SignalUpdate; +}; + +struct HostMessagesUnion { + HostMessages type; + void *value; + + HostMessagesUnion() : type(HostMessages::NONE), value(nullptr) {} + HostMessagesUnion(HostMessagesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(HostMessages::NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + HostMessagesUnion(const HostMessagesUnion &); + HostMessagesUnion &operator=(const HostMessagesUnion &u) + { HostMessagesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + HostMessagesUnion &operator=(HostMessagesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~HostMessagesUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = HostMessagesUnionTraits::enum_value; + if (type != HostMessages::NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, HostMessages type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + rpc::ExecRequestT *AsExecRequest() { + return type == HostMessages::ExecRequest ? + reinterpret_cast(value) : nullptr; + } + const rpc::ExecRequestT *AsExecRequest() const { + return type == HostMessages::ExecRequest ? + reinterpret_cast(value) : nullptr; + } + rpc::SignalUpdateT *AsSignalUpdate() { + return type == HostMessages::SignalUpdate ? + reinterpret_cast(value) : nullptr; + } + const rpc::SignalUpdateT *AsSignalUpdate() const { + return type == HostMessages::SignalUpdate ? + reinterpret_cast(value) : nullptr; + } +}; + +bool VerifyHostMessages(flatbuffers::Verifier &verifier, const void *obj, HostMessages type); +bool VerifyHostMessagesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum class ExecutorMessages : uint8_t { + NONE = 0, + ExecResult = 1, + Executing = 2, + Stats = 3, + MIN = NONE, + MAX = Stats +}; + +inline const ExecutorMessages (&EnumValuesExecutorMessages())[4] { + static const ExecutorMessages values[] = { + ExecutorMessages::NONE, + ExecutorMessages::ExecResult, + ExecutorMessages::Executing, + ExecutorMessages::Stats + }; + return values; +} + +inline const char * const *EnumNamesExecutorMessages() { + static const char * const names[5] = { + "NONE", + "ExecResult", + "Executing", + "Stats", + nullptr + }; + return names; +} + +inline const char *EnumNameExecutorMessages(ExecutorMessages e) { + if (flatbuffers::IsOutRange(e, ExecutorMessages::NONE, ExecutorMessages::Stats)) return ""; + const size_t index = static_cast(e); + return EnumNamesExecutorMessages()[index]; +} + +template struct ExecutorMessagesTraits { + static const ExecutorMessages enum_value = ExecutorMessages::NONE; +}; + +template<> struct ExecutorMessagesTraits { + static const ExecutorMessages enum_value = ExecutorMessages::ExecResult; +}; + +template<> struct ExecutorMessagesTraits { + static const ExecutorMessages enum_value = ExecutorMessages::Executing; +}; + +template<> struct ExecutorMessagesTraits { + static const ExecutorMessages enum_value = ExecutorMessages::Stats; +}; + +template struct ExecutorMessagesUnionTraits { + static const ExecutorMessages enum_value = ExecutorMessages::NONE; +}; + +template<> struct ExecutorMessagesUnionTraits { + static const ExecutorMessages enum_value = ExecutorMessages::ExecResult; +}; + +template<> struct ExecutorMessagesUnionTraits { + static const ExecutorMessages enum_value = ExecutorMessages::Executing; +}; + +template<> struct ExecutorMessagesUnionTraits { + static const ExecutorMessages enum_value = ExecutorMessages::Stats; +}; + +struct ExecutorMessagesUnion { + ExecutorMessages type; + void *value; + + ExecutorMessagesUnion() : type(ExecutorMessages::NONE), value(nullptr) {} + ExecutorMessagesUnion(ExecutorMessagesUnion&& u) FLATBUFFERS_NOEXCEPT : + type(ExecutorMessages::NONE), value(nullptr) + { std::swap(type, u.type); std::swap(value, u.value); } + ExecutorMessagesUnion(const ExecutorMessagesUnion &); + ExecutorMessagesUnion &operator=(const ExecutorMessagesUnion &u) + { ExecutorMessagesUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } + ExecutorMessagesUnion &operator=(ExecutorMessagesUnion &&u) FLATBUFFERS_NOEXCEPT + { std::swap(type, u.type); std::swap(value, u.value); return *this; } + ~ExecutorMessagesUnion() { Reset(); } + + void Reset(); + + template + void Set(T&& val) { + typedef typename std::remove_reference::type RT; + Reset(); + type = ExecutorMessagesUnionTraits::enum_value; + if (type != ExecutorMessages::NONE) { + value = new RT(std::forward(val)); + } + } + + static void *UnPack(const void *obj, ExecutorMessages type, const flatbuffers::resolver_function_t *resolver); + flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; + + rpc::ExecResultT *AsExecResult() { + return type == ExecutorMessages::ExecResult ? + reinterpret_cast(value) : nullptr; + } + const rpc::ExecResultT *AsExecResult() const { + return type == ExecutorMessages::ExecResult ? + reinterpret_cast(value) : nullptr; + } + rpc::ExecutingMessageT *AsExecuting() { + return type == ExecutorMessages::Executing ? + reinterpret_cast(value) : nullptr; + } + const rpc::ExecutingMessageT *AsExecuting() const { + return type == ExecutorMessages::Executing ? + reinterpret_cast(value) : nullptr; + } + rpc::StatsMessageT *AsStats() { + return type == ExecutorMessages::Stats ? + reinterpret_cast(value) : nullptr; + } + const rpc::StatsMessageT *AsStats() const { + return type == ExecutorMessages::Stats ? + reinterpret_cast(value) : nullptr; + } +}; + +bool VerifyExecutorMessages(flatbuffers::Verifier &verifier, const void *obj, ExecutorMessages type); +bool VerifyExecutorMessagesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector> *values, const flatbuffers::Vector *types); + +enum class RequestFlag : uint64_t { + IsBinary = 1ULL, + NewSignal = 2ULL, + ResetState = 4ULL, + ReturnOutput = 8ULL, + ReturnError = 16ULL, + NONE = 0, + ANY = 31ULL +}; +FLATBUFFERS_DEFINE_BITMASK_OPERATORS(RequestFlag, uint64_t) + +inline const RequestFlag (&EnumValuesRequestFlag())[5] { + static const RequestFlag values[] = { + RequestFlag::IsBinary, + RequestFlag::NewSignal, + RequestFlag::ResetState, + RequestFlag::ReturnOutput, + RequestFlag::ReturnError + }; + return values; +} + +inline const char * const *EnumNamesRequestFlag() { + static const char * const names[17] = { + "IsBinary", + "NewSignal", + "", + "ResetState", + "", + "", + "", + "ReturnOutput", + "", + "", + "", + "", + "", + "", + "", + "ReturnError", + nullptr + }; + return names; +} + +inline const char *EnumNameRequestFlag(RequestFlag e) { + if (flatbuffers::IsOutRange(e, RequestFlag::IsBinary, RequestFlag::ReturnError)) return ""; + const size_t index = static_cast(e) - static_cast(RequestFlag::IsBinary); + return EnumNamesRequestFlag()[index]; +} + +enum class ExecEnv : uint64_t { + Debug = 1ULL, + Signal = 2ULL, + SandboxSetuid = 4ULL, + SandboxNamespace = 8ULL, + SandboxAndroid = 16ULL, + ExtraCover = 32ULL, + EnableTun = 64ULL, + EnableNetDev = 128ULL, + EnableNetReset = 256ULL, + EnableCgroups = 512ULL, + EnableCloseFds = 1024ULL, + EnableDevlinkPCI = 2048ULL, + EnableVhciInjection = 4096ULL, + EnableWifi = 8192ULL, + DelayKcovMmap = 16384ULL, + EnableNicVF = 32768ULL, + NONE = 0, + ANY = 65535ULL +}; +FLATBUFFERS_DEFINE_BITMASK_OPERATORS(ExecEnv, uint64_t) + +inline const ExecEnv (&EnumValuesExecEnv())[16] { + static const ExecEnv values[] = { + ExecEnv::Debug, + ExecEnv::Signal, + ExecEnv::SandboxSetuid, + ExecEnv::SandboxNamespace, + ExecEnv::SandboxAndroid, + ExecEnv::ExtraCover, + ExecEnv::EnableTun, + ExecEnv::EnableNetDev, + ExecEnv::EnableNetReset, + ExecEnv::EnableCgroups, + ExecEnv::EnableCloseFds, + ExecEnv::EnableDevlinkPCI, + ExecEnv::EnableVhciInjection, + ExecEnv::EnableWifi, + ExecEnv::DelayKcovMmap, + ExecEnv::EnableNicVF + }; + return values; +} + +inline const char *EnumNameExecEnv(ExecEnv e) { + switch (e) { + case ExecEnv::Debug: return "Debug"; + case ExecEnv::Signal: return "Signal"; + case ExecEnv::SandboxSetuid: return "SandboxSetuid"; + case ExecEnv::SandboxNamespace: return "SandboxNamespace"; + case ExecEnv::SandboxAndroid: return "SandboxAndroid"; + case ExecEnv::ExtraCover: return "ExtraCover"; + case ExecEnv::EnableTun: return "EnableTun"; + case ExecEnv::EnableNetDev: return "EnableNetDev"; + case ExecEnv::EnableNetReset: return "EnableNetReset"; + case ExecEnv::EnableCgroups: return "EnableCgroups"; + case ExecEnv::EnableCloseFds: return "EnableCloseFds"; + case ExecEnv::EnableDevlinkPCI: return "EnableDevlinkPCI"; + case ExecEnv::EnableVhciInjection: return "EnableVhciInjection"; + case ExecEnv::EnableWifi: return "EnableWifi"; + case ExecEnv::DelayKcovMmap: return "DelayKcovMmap"; + case ExecEnv::EnableNicVF: return "EnableNicVF"; + default: return ""; + } +} + +enum class ExecFlag : uint64_t { + CollectSignal = 1ULL, + CollectCover = 2ULL, + DedupCover = 4ULL, + CollectComps = 8ULL, + Threaded = 16ULL, + CoverFilter = 32ULL, + NONE = 0, + ANY = 63ULL +}; +FLATBUFFERS_DEFINE_BITMASK_OPERATORS(ExecFlag, uint64_t) + +inline const ExecFlag (&EnumValuesExecFlag())[6] { + static const ExecFlag values[] = { + ExecFlag::CollectSignal, + ExecFlag::CollectCover, + ExecFlag::DedupCover, + ExecFlag::CollectComps, + ExecFlag::Threaded, + ExecFlag::CoverFilter + }; + return values; +} + +inline const char *EnumNameExecFlag(ExecFlag e) { + switch (e) { + case ExecFlag::CollectSignal: return "CollectSignal"; + case ExecFlag::CollectCover: return "CollectCover"; + case ExecFlag::DedupCover: return "DedupCover"; + case ExecFlag::CollectComps: return "CollectComps"; + case ExecFlag::Threaded: return "Threaded"; + case ExecFlag::CoverFilter: return "CoverFilter"; + default: return ""; + } +} + +enum class CallFlag : uint8_t { + Executed = 1, + Finished = 2, + Blocked = 4, + FaultInjected = 8, + NONE = 0, + ANY = 15 +}; +FLATBUFFERS_DEFINE_BITMASK_OPERATORS(CallFlag, uint8_t) + +inline const CallFlag (&EnumValuesCallFlag())[4] { + static const CallFlag values[] = { + CallFlag::Executed, + CallFlag::Finished, + CallFlag::Blocked, + CallFlag::FaultInjected + }; + return values; +} + +inline const char * const *EnumNamesCallFlag() { + static const char * const names[9] = { + "Executed", + "Finished", + "", + "Blocked", + "", + "", + "", + "FaultInjected", + nullptr + }; + return names; +} + +inline const char *EnumNameCallFlag(CallFlag e) { + if (flatbuffers::IsOutRange(e, CallFlag::Executed, CallFlag::FaultInjected)) return ""; + const size_t index = static_cast(e) - static_cast(CallFlag::Executed); + return EnumNamesCallFlag()[index]; +} + +FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Comparison FLATBUFFERS_FINAL_CLASS { + private: + uint64_t op1_; + uint64_t op2_; + + public: + Comparison() + : op1_(0), + op2_(0) { + } + Comparison(uint64_t _op1, uint64_t _op2) + : op1_(flatbuffers::EndianScalar(_op1)), + op2_(flatbuffers::EndianScalar(_op2)) { + } + uint64_t op1() const { + return flatbuffers::EndianScalar(op1_); + } + uint64_t op2() const { + return flatbuffers::EndianScalar(op2_); + } +}; +FLATBUFFERS_STRUCT_END(Comparison, 16); + +struct ConnectRequestT : public flatbuffers::NativeTable { + typedef ConnectRequest TableType; + std::string name{}; + std::string arch{}; + std::string git_revision{}; + std::string syz_revision{}; +}; + +struct ConnectRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConnectRequestT NativeTableType; + typedef ConnectRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_ARCH = 6, + VT_GIT_REVISION = 8, + VT_SYZ_REVISION = 10 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + const flatbuffers::String *arch() const { + return GetPointer(VT_ARCH); + } + const flatbuffers::String *git_revision() const { + return GetPointer(VT_GIT_REVISION); + } + const flatbuffers::String *syz_revision() const { + return GetPointer(VT_SYZ_REVISION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_ARCH) && + verifier.VerifyString(arch()) && + VerifyOffset(verifier, VT_GIT_REVISION) && + verifier.VerifyString(git_revision()) && + VerifyOffset(verifier, VT_SYZ_REVISION) && + verifier.VerifyString(syz_revision()) && + verifier.EndTable(); + } + ConnectRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ConnectRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ConnectRequestBuilder { + typedef ConnectRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(ConnectRequest::VT_NAME, name); + } + void add_arch(flatbuffers::Offset arch) { + fbb_.AddOffset(ConnectRequest::VT_ARCH, arch); + } + void add_git_revision(flatbuffers::Offset git_revision) { + fbb_.AddOffset(ConnectRequest::VT_GIT_REVISION, git_revision); + } + void add_syz_revision(flatbuffers::Offset syz_revision) { + fbb_.AddOffset(ConnectRequest::VT_SYZ_REVISION, syz_revision); + } + explicit ConnectRequestBuilder(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 CreateConnectRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + flatbuffers::Offset arch = 0, + flatbuffers::Offset git_revision = 0, + flatbuffers::Offset syz_revision = 0) { + ConnectRequestBuilder builder_(_fbb); + builder_.add_syz_revision(syz_revision); + builder_.add_git_revision(git_revision); + builder_.add_arch(arch); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateConnectRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const char *arch = nullptr, + const char *git_revision = nullptr, + const char *syz_revision = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto arch__ = arch ? _fbb.CreateString(arch) : 0; + auto git_revision__ = git_revision ? _fbb.CreateString(git_revision) : 0; + auto syz_revision__ = syz_revision ? _fbb.CreateString(syz_revision) : 0; + return rpc::CreateConnectRequest( + _fbb, + name__, + arch__, + git_revision__, + syz_revision__); +} + +flatbuffers::Offset CreateConnectRequest(flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ConnectReplyT : public flatbuffers::NativeTable { + typedef ConnectReply TableType; + std::vector leak_frames{}; + std::vector race_frames{}; + rpc::Feature features = static_cast(0); + std::vector files{}; + std::vector globs{}; +}; + +struct ConnectReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConnectReplyT NativeTableType; + typedef ConnectReplyBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_LEAK_FRAMES = 4, + VT_RACE_FRAMES = 6, + VT_FEATURES = 8, + VT_FILES = 10, + VT_GLOBS = 12 + }; + const flatbuffers::Vector> *leak_frames() const { + return GetPointer> *>(VT_LEAK_FRAMES); + } + const flatbuffers::Vector> *race_frames() const { + return GetPointer> *>(VT_RACE_FRAMES); + } + rpc::Feature features() const { + return static_cast(GetField(VT_FEATURES, 0)); + } + const flatbuffers::Vector> *files() const { + return GetPointer> *>(VT_FILES); + } + const flatbuffers::Vector> *globs() const { + return GetPointer> *>(VT_GLOBS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_LEAK_FRAMES) && + verifier.VerifyVector(leak_frames()) && + verifier.VerifyVectorOfStrings(leak_frames()) && + VerifyOffset(verifier, VT_RACE_FRAMES) && + verifier.VerifyVector(race_frames()) && + verifier.VerifyVectorOfStrings(race_frames()) && + VerifyField(verifier, VT_FEATURES, 8) && + VerifyOffset(verifier, VT_FILES) && + verifier.VerifyVector(files()) && + verifier.VerifyVectorOfStrings(files()) && + VerifyOffset(verifier, VT_GLOBS) && + verifier.VerifyVector(globs()) && + verifier.VerifyVectorOfStrings(globs()) && + verifier.EndTable(); + } + ConnectReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ConnectReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ConnectReplyBuilder { + typedef ConnectReply Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_leak_frames(flatbuffers::Offset>> leak_frames) { + fbb_.AddOffset(ConnectReply::VT_LEAK_FRAMES, leak_frames); + } + void add_race_frames(flatbuffers::Offset>> race_frames) { + fbb_.AddOffset(ConnectReply::VT_RACE_FRAMES, race_frames); + } + void add_features(rpc::Feature features) { + fbb_.AddElement(ConnectReply::VT_FEATURES, static_cast(features), 0); + } + void add_files(flatbuffers::Offset>> files) { + fbb_.AddOffset(ConnectReply::VT_FILES, files); + } + void add_globs(flatbuffers::Offset>> globs) { + fbb_.AddOffset(ConnectReply::VT_GLOBS, globs); + } + explicit ConnectReplyBuilder(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 CreateConnectReply( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> leak_frames = 0, + flatbuffers::Offset>> race_frames = 0, + rpc::Feature features = static_cast(0), + flatbuffers::Offset>> files = 0, + flatbuffers::Offset>> globs = 0) { + ConnectReplyBuilder builder_(_fbb); + builder_.add_features(features); + builder_.add_globs(globs); + builder_.add_files(files); + builder_.add_race_frames(race_frames); + builder_.add_leak_frames(leak_frames); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateConnectReplyDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *leak_frames = nullptr, + const std::vector> *race_frames = nullptr, + rpc::Feature features = static_cast(0), + const std::vector> *files = nullptr, + const std::vector> *globs = nullptr) { + auto leak_frames__ = leak_frames ? _fbb.CreateVector>(*leak_frames) : 0; + auto race_frames__ = race_frames ? _fbb.CreateVector>(*race_frames) : 0; + auto files__ = files ? _fbb.CreateVector>(*files) : 0; + auto globs__ = globs ? _fbb.CreateVector>(*globs) : 0; + return rpc::CreateConnectReply( + _fbb, + leak_frames__, + race_frames__, + features, + files__, + globs__); +} + +flatbuffers::Offset CreateConnectReply(flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct InfoRequestT : public flatbuffers::NativeTable { + typedef InfoRequest TableType; + std::string error{}; + rpc::Feature features = static_cast(0); + std::vector> globs{}; + std::vector> files{}; + InfoRequestT() = default; + InfoRequestT(const InfoRequestT &o); + InfoRequestT(InfoRequestT&&) FLATBUFFERS_NOEXCEPT = default; + InfoRequestT &operator=(InfoRequestT o) FLATBUFFERS_NOEXCEPT; +}; + +struct InfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InfoRequestT NativeTableType; + typedef InfoRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ERROR = 4, + VT_FEATURES = 6, + VT_GLOBS = 8, + VT_FILES = 10 + }; + const flatbuffers::String *error() const { + return GetPointer(VT_ERROR); + } + rpc::Feature features() const { + return static_cast(GetField(VT_FEATURES, 0)); + } + const flatbuffers::Vector> *globs() const { + return GetPointer> *>(VT_GLOBS); + } + const flatbuffers::Vector> *files() const { + return GetPointer> *>(VT_FILES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_ERROR) && + verifier.VerifyString(error()) && + VerifyField(verifier, VT_FEATURES, 8) && + VerifyOffset(verifier, VT_GLOBS) && + verifier.VerifyVector(globs()) && + verifier.VerifyVectorOfTables(globs()) && + VerifyOffset(verifier, VT_FILES) && + verifier.VerifyVector(files()) && + verifier.VerifyVectorOfTables(files()) && + verifier.EndTable(); + } + InfoRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(InfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct InfoRequestBuilder { + typedef InfoRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_error(flatbuffers::Offset error) { + fbb_.AddOffset(InfoRequest::VT_ERROR, error); + } + void add_features(rpc::Feature features) { + fbb_.AddElement(InfoRequest::VT_FEATURES, static_cast(features), 0); + } + void add_globs(flatbuffers::Offset>> globs) { + fbb_.AddOffset(InfoRequest::VT_GLOBS, globs); + } + void add_files(flatbuffers::Offset>> files) { + fbb_.AddOffset(InfoRequest::VT_FILES, files); + } + explicit InfoRequestBuilder(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 CreateInfoRequest( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset error = 0, + rpc::Feature features = static_cast(0), + flatbuffers::Offset>> globs = 0, + flatbuffers::Offset>> files = 0) { + InfoRequestBuilder builder_(_fbb); + builder_.add_features(features); + builder_.add_files(files); + builder_.add_globs(globs); + builder_.add_error(error); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateInfoRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *error = nullptr, + rpc::Feature features = static_cast(0), + const std::vector> *globs = nullptr, + const std::vector> *files = nullptr) { + auto error__ = error ? _fbb.CreateString(error) : 0; + auto globs__ = globs ? _fbb.CreateVector>(*globs) : 0; + auto files__ = files ? _fbb.CreateVector>(*files) : 0; + return rpc::CreateInfoRequest( + _fbb, + error__, + features, + globs__, + files__); +} + +flatbuffers::Offset CreateInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct InfoReplyT : public flatbuffers::NativeTable { + typedef InfoReply TableType; + std::vector cover_filter{}; +}; + +struct InfoReply FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef InfoReplyT NativeTableType; + typedef InfoReplyBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_COVER_FILTER = 4 + }; + const flatbuffers::Vector *cover_filter() const { + return GetPointer *>(VT_COVER_FILTER); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_COVER_FILTER) && + verifier.VerifyVector(cover_filter()) && + verifier.EndTable(); + } + InfoReplyT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(InfoReplyT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct InfoReplyBuilder { + typedef InfoReply Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_cover_filter(flatbuffers::Offset> cover_filter) { + fbb_.AddOffset(InfoReply::VT_COVER_FILTER, cover_filter); + } + explicit InfoReplyBuilder(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 CreateInfoReply( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> cover_filter = 0) { + InfoReplyBuilder builder_(_fbb); + builder_.add_cover_filter(cover_filter); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateInfoReplyDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *cover_filter = nullptr) { + auto cover_filter__ = cover_filter ? _fbb.CreateVector(*cover_filter) : 0; + return rpc::CreateInfoReply( + _fbb, + cover_filter__); +} + +flatbuffers::Offset CreateInfoReply(flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct FileInfoT : public flatbuffers::NativeTable { + typedef FileInfo TableType; + std::string name{}; + bool exists = false; + std::string error{}; + std::vector data{}; +}; + +struct FileInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef FileInfoT NativeTableType; + typedef FileInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_EXISTS = 6, + VT_ERROR = 8, + VT_DATA = 10 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + bool exists() const { + return GetField(VT_EXISTS, 0) != 0; + } + const flatbuffers::String *error() const { + return GetPointer(VT_ERROR); + } + const flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyField(verifier, VT_EXISTS, 1) && + VerifyOffset(verifier, VT_ERROR) && + verifier.VerifyString(error()) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } + FileInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(FileInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const FileInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct FileInfoBuilder { + typedef FileInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(FileInfo::VT_NAME, name); + } + void add_exists(bool exists) { + fbb_.AddElement(FileInfo::VT_EXISTS, static_cast(exists), 0); + } + void add_error(flatbuffers::Offset error) { + fbb_.AddOffset(FileInfo::VT_ERROR, error); + } + void add_data(flatbuffers::Offset> data) { + fbb_.AddOffset(FileInfo::VT_DATA, data); + } + explicit FileInfoBuilder(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 CreateFileInfo( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + bool exists = false, + flatbuffers::Offset error = 0, + flatbuffers::Offset> data = 0) { + FileInfoBuilder builder_(_fbb); + builder_.add_data(data); + builder_.add_error(error); + builder_.add_name(name); + builder_.add_exists(exists); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateFileInfoDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + bool exists = false, + const char *error = nullptr, + const std::vector *data = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto error__ = error ? _fbb.CreateString(error) : 0; + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return rpc::CreateFileInfo( + _fbb, + name__, + exists, + error__, + data__); +} + +flatbuffers::Offset CreateFileInfo(flatbuffers::FlatBufferBuilder &_fbb, const FileInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct GlobInfoT : public flatbuffers::NativeTable { + typedef GlobInfo TableType; + std::string name{}; + std::vector files{}; +}; + +struct GlobInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef GlobInfoT NativeTableType; + typedef GlobInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_FILES = 6 + }; + const flatbuffers::String *name() const { + return GetPointer(VT_NAME); + } + const flatbuffers::Vector> *files() const { + return GetPointer> *>(VT_FILES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_FILES) && + verifier.VerifyVector(files()) && + verifier.VerifyVectorOfStrings(files()) && + verifier.EndTable(); + } + GlobInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GlobInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct GlobInfoBuilder { + typedef GlobInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset name) { + fbb_.AddOffset(GlobInfo::VT_NAME, name); + } + void add_files(flatbuffers::Offset>> files) { + fbb_.AddOffset(GlobInfo::VT_FILES, files); + } + explicit GlobInfoBuilder(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 CreateGlobInfo( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset name = 0, + flatbuffers::Offset>> files = 0) { + GlobInfoBuilder builder_(_fbb); + builder_.add_files(files); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateGlobInfoDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const std::vector> *files = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto files__ = files ? _fbb.CreateVector>(*files) : 0; + return rpc::CreateGlobInfo( + _fbb, + name__, + files__); +} + +flatbuffers::Offset CreateGlobInfo(flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct HostMessageT : public flatbuffers::NativeTable { + typedef HostMessage TableType; + rpc::HostMessagesUnion msg{}; +}; + +struct HostMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef HostMessageT NativeTableType; + typedef HostMessageBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MSG_TYPE = 4, + VT_MSG = 6 + }; + rpc::HostMessages msg_type() const { + return static_cast(GetField(VT_MSG_TYPE, 0)); + } + const void *msg() const { + return GetPointer(VT_MSG); + } + template const T *msg_as() const; + const rpc::ExecRequest *msg_as_ExecRequest() const { + return msg_type() == rpc::HostMessages::ExecRequest ? static_cast(msg()) : nullptr; + } + const rpc::SignalUpdate *msg_as_SignalUpdate() const { + return msg_type() == rpc::HostMessages::SignalUpdate ? static_cast(msg()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_MSG_TYPE, 1) && + VerifyOffset(verifier, VT_MSG) && + VerifyHostMessages(verifier, msg(), msg_type()) && + verifier.EndTable(); + } + HostMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(HostMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +template<> inline const rpc::ExecRequest *HostMessage::msg_as() const { + return msg_as_ExecRequest(); +} + +template<> inline const rpc::SignalUpdate *HostMessage::msg_as() const { + return msg_as_SignalUpdate(); +} + +struct HostMessageBuilder { + typedef HostMessage Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_msg_type(rpc::HostMessages msg_type) { + fbb_.AddElement(HostMessage::VT_MSG_TYPE, static_cast(msg_type), 0); + } + void add_msg(flatbuffers::Offset msg) { + fbb_.AddOffset(HostMessage::VT_MSG, msg); + } + explicit HostMessageBuilder(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 CreateHostMessage( + flatbuffers::FlatBufferBuilder &_fbb, + rpc::HostMessages msg_type = rpc::HostMessages::NONE, + flatbuffers::Offset msg = 0) { + HostMessageBuilder builder_(_fbb); + builder_.add_msg(msg); + builder_.add_msg_type(msg_type); + return builder_.Finish(); +} + +flatbuffers::Offset CreateHostMessage(flatbuffers::FlatBufferBuilder &_fbb, const HostMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ExecutorMessageT : public flatbuffers::NativeTable { + typedef ExecutorMessage TableType; + rpc::ExecutorMessagesUnion msg{}; +}; + +struct ExecutorMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ExecutorMessageT NativeTableType; + typedef ExecutorMessageBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MSG_TYPE = 4, + VT_MSG = 6 + }; + rpc::ExecutorMessages msg_type() const { + return static_cast(GetField(VT_MSG_TYPE, 0)); + } + const void *msg() const { + return GetPointer(VT_MSG); + } + template const T *msg_as() const; + const rpc::ExecResult *msg_as_ExecResult() const { + return msg_type() == rpc::ExecutorMessages::ExecResult ? static_cast(msg()) : nullptr; + } + const rpc::ExecutingMessage *msg_as_Executing() const { + return msg_type() == rpc::ExecutorMessages::Executing ? static_cast(msg()) : nullptr; + } + const rpc::StatsMessage *msg_as_Stats() const { + return msg_type() == rpc::ExecutorMessages::Stats ? static_cast(msg()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_MSG_TYPE, 1) && + VerifyOffset(verifier, VT_MSG) && + VerifyExecutorMessages(verifier, msg(), msg_type()) && + verifier.EndTable(); + } + ExecutorMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ExecutorMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +template<> inline const rpc::ExecResult *ExecutorMessage::msg_as() const { + return msg_as_ExecResult(); +} + +template<> inline const rpc::ExecutingMessage *ExecutorMessage::msg_as() const { + return msg_as_Executing(); +} + +template<> inline const rpc::StatsMessage *ExecutorMessage::msg_as() const { + return msg_as_Stats(); +} + +struct ExecutorMessageBuilder { + typedef ExecutorMessage Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_msg_type(rpc::ExecutorMessages msg_type) { + fbb_.AddElement(ExecutorMessage::VT_MSG_TYPE, static_cast(msg_type), 0); + } + void add_msg(flatbuffers::Offset msg) { + fbb_.AddOffset(ExecutorMessage::VT_MSG, msg); + } + explicit ExecutorMessageBuilder(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 CreateExecutorMessage( + flatbuffers::FlatBufferBuilder &_fbb, + rpc::ExecutorMessages msg_type = rpc::ExecutorMessages::NONE, + flatbuffers::Offset msg = 0) { + ExecutorMessageBuilder builder_(_fbb); + builder_.add_msg(msg); + builder_.add_msg_type(msg_type); + return builder_.Finish(); +} + +flatbuffers::Offset CreateExecutorMessage(flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ExecRequestT : public flatbuffers::NativeTable { + typedef ExecRequest TableType; + int64_t id = 0; + std::vector prog_data{}; + rpc::RequestFlag flags = static_cast(0); + rpc::ExecEnv exec_env = static_cast(0); + rpc::ExecFlag exec_flags = static_cast(0); + int64_t sandbox_arg = 0; + std::vector signal_filter{}; + int32_t signal_filter_call = 0; + int32_t repeat = 0; +}; + +struct ExecRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ExecRequestT NativeTableType; + typedef ExecRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4, + VT_PROG_DATA = 6, + VT_FLAGS = 8, + VT_EXEC_ENV = 10, + VT_EXEC_FLAGS = 12, + VT_SANDBOX_ARG = 14, + VT_SIGNAL_FILTER = 16, + VT_SIGNAL_FILTER_CALL = 18, + VT_REPEAT = 20 + }; + int64_t id() const { + return GetField(VT_ID, 0); + } + const flatbuffers::Vector *prog_data() const { + return GetPointer *>(VT_PROG_DATA); + } + rpc::RequestFlag flags() const { + return static_cast(GetField(VT_FLAGS, 0)); + } + rpc::ExecEnv exec_env() const { + return static_cast(GetField(VT_EXEC_ENV, 0)); + } + rpc::ExecFlag exec_flags() const { + return static_cast(GetField(VT_EXEC_FLAGS, 0)); + } + int64_t sandbox_arg() const { + return GetField(VT_SANDBOX_ARG, 0); + } + const flatbuffers::Vector *signal_filter() const { + return GetPointer *>(VT_SIGNAL_FILTER); + } + int32_t signal_filter_call() const { + return GetField(VT_SIGNAL_FILTER_CALL, 0); + } + int32_t repeat() const { + return GetField(VT_REPEAT, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ID, 8) && + VerifyOffset(verifier, VT_PROG_DATA) && + verifier.VerifyVector(prog_data()) && + VerifyField(verifier, VT_FLAGS, 8) && + VerifyField(verifier, VT_EXEC_ENV, 8) && + VerifyField(verifier, VT_EXEC_FLAGS, 8) && + VerifyField(verifier, VT_SANDBOX_ARG, 8) && + VerifyOffset(verifier, VT_SIGNAL_FILTER) && + verifier.VerifyVector(signal_filter()) && + VerifyField(verifier, VT_SIGNAL_FILTER_CALL, 4) && + VerifyField(verifier, VT_REPEAT, 4) && + verifier.EndTable(); + } + ExecRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ExecRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ExecRequestBuilder { + typedef ExecRequest Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(int64_t id) { + fbb_.AddElement(ExecRequest::VT_ID, id, 0); + } + void add_prog_data(flatbuffers::Offset> prog_data) { + fbb_.AddOffset(ExecRequest::VT_PROG_DATA, prog_data); + } + void add_flags(rpc::RequestFlag flags) { + fbb_.AddElement(ExecRequest::VT_FLAGS, static_cast(flags), 0); + } + void add_exec_env(rpc::ExecEnv exec_env) { + fbb_.AddElement(ExecRequest::VT_EXEC_ENV, static_cast(exec_env), 0); + } + void add_exec_flags(rpc::ExecFlag exec_flags) { + fbb_.AddElement(ExecRequest::VT_EXEC_FLAGS, static_cast(exec_flags), 0); + } + void add_sandbox_arg(int64_t sandbox_arg) { + fbb_.AddElement(ExecRequest::VT_SANDBOX_ARG, sandbox_arg, 0); + } + void add_signal_filter(flatbuffers::Offset> signal_filter) { + fbb_.AddOffset(ExecRequest::VT_SIGNAL_FILTER, signal_filter); + } + void add_signal_filter_call(int32_t signal_filter_call) { + fbb_.AddElement(ExecRequest::VT_SIGNAL_FILTER_CALL, signal_filter_call, 0); + } + void add_repeat(int32_t repeat) { + fbb_.AddElement(ExecRequest::VT_REPEAT, repeat, 0); + } + explicit ExecRequestBuilder(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 CreateExecRequest( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t id = 0, + flatbuffers::Offset> prog_data = 0, + rpc::RequestFlag flags = static_cast(0), + rpc::ExecEnv exec_env = static_cast(0), + rpc::ExecFlag exec_flags = static_cast(0), + int64_t sandbox_arg = 0, + flatbuffers::Offset> signal_filter = 0, + int32_t signal_filter_call = 0, + int32_t repeat = 0) { + ExecRequestBuilder builder_(_fbb); + builder_.add_sandbox_arg(sandbox_arg); + builder_.add_exec_flags(exec_flags); + builder_.add_exec_env(exec_env); + builder_.add_flags(flags); + builder_.add_id(id); + builder_.add_repeat(repeat); + builder_.add_signal_filter_call(signal_filter_call); + builder_.add_signal_filter(signal_filter); + builder_.add_prog_data(prog_data); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateExecRequestDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t id = 0, + const std::vector *prog_data = nullptr, + rpc::RequestFlag flags = static_cast(0), + rpc::ExecEnv exec_env = static_cast(0), + rpc::ExecFlag exec_flags = static_cast(0), + int64_t sandbox_arg = 0, + const std::vector *signal_filter = nullptr, + int32_t signal_filter_call = 0, + int32_t repeat = 0) { + auto prog_data__ = prog_data ? _fbb.CreateVector(*prog_data) : 0; + auto signal_filter__ = signal_filter ? _fbb.CreateVector(*signal_filter) : 0; + return rpc::CreateExecRequest( + _fbb, + id, + prog_data__, + flags, + exec_env, + exec_flags, + sandbox_arg, + signal_filter__, + signal_filter_call, + repeat); +} + +flatbuffers::Offset CreateExecRequest(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct SignalUpdateT : public flatbuffers::NativeTable { + typedef SignalUpdate TableType; + std::vector new_max{}; + std::vector drop_max{}; +}; + +struct SignalUpdate FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SignalUpdateT NativeTableType; + typedef SignalUpdateBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NEW_MAX = 4, + VT_DROP_MAX = 6 + }; + const flatbuffers::Vector *new_max() const { + return GetPointer *>(VT_NEW_MAX); + } + const flatbuffers::Vector *drop_max() const { + return GetPointer *>(VT_DROP_MAX); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NEW_MAX) && + verifier.VerifyVector(new_max()) && + VerifyOffset(verifier, VT_DROP_MAX) && + verifier.VerifyVector(drop_max()) && + verifier.EndTable(); + } + SignalUpdateT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(SignalUpdateT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct SignalUpdateBuilder { + typedef SignalUpdate Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_new_max(flatbuffers::Offset> new_max) { + fbb_.AddOffset(SignalUpdate::VT_NEW_MAX, new_max); + } + void add_drop_max(flatbuffers::Offset> drop_max) { + fbb_.AddOffset(SignalUpdate::VT_DROP_MAX, drop_max); + } + explicit SignalUpdateBuilder(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 CreateSignalUpdate( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset> new_max = 0, + flatbuffers::Offset> drop_max = 0) { + SignalUpdateBuilder builder_(_fbb); + builder_.add_drop_max(drop_max); + builder_.add_new_max(new_max); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateSignalUpdateDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector *new_max = nullptr, + const std::vector *drop_max = nullptr) { + auto new_max__ = new_max ? _fbb.CreateVector(*new_max) : 0; + auto drop_max__ = drop_max ? _fbb.CreateVector(*drop_max) : 0; + return rpc::CreateSignalUpdate( + _fbb, + new_max__, + drop_max__); +} + +flatbuffers::Offset CreateSignalUpdate(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ExecutingMessageT : public flatbuffers::NativeTable { + typedef ExecutingMessage TableType; + int64_t id = 0; + int32_t proc_id = 0; + int32_t try_ = 0; +}; + +struct ExecutingMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ExecutingMessageT NativeTableType; + typedef ExecutingMessageBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ID = 4, + VT_PROC_ID = 6, + VT_TRY_ = 8 + }; + int64_t id() const { + return GetField(VT_ID, 0); + } + int32_t proc_id() const { + return GetField(VT_PROC_ID, 0); + } + int32_t try_() const { + return GetField(VT_TRY_, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_ID, 8) && + VerifyField(verifier, VT_PROC_ID, 4) && + VerifyField(verifier, VT_TRY_, 4) && + verifier.EndTable(); + } + ExecutingMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ExecutingMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ExecutingMessageBuilder { + typedef ExecutingMessage Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_id(int64_t id) { + fbb_.AddElement(ExecutingMessage::VT_ID, id, 0); + } + void add_proc_id(int32_t proc_id) { + fbb_.AddElement(ExecutingMessage::VT_PROC_ID, proc_id, 0); + } + void add_try_(int32_t try_) { + fbb_.AddElement(ExecutingMessage::VT_TRY_, try_, 0); + } + explicit ExecutingMessageBuilder(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 CreateExecutingMessage( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t id = 0, + int32_t proc_id = 0, + int32_t try_ = 0) { + ExecutingMessageBuilder builder_(_fbb); + builder_.add_id(id); + builder_.add_try_(try_); + builder_.add_proc_id(proc_id); + return builder_.Finish(); +} + +flatbuffers::Offset CreateExecutingMessage(flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct StatsMessageT : public flatbuffers::NativeTable { + typedef StatsMessage TableType; + int64_t noexec_count = 0; + int64_t noexec_duration = 0; +}; + +struct StatsMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef StatsMessageT NativeTableType; + typedef StatsMessageBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NOEXEC_COUNT = 4, + VT_NOEXEC_DURATION = 6 + }; + int64_t noexec_count() const { + return GetField(VT_NOEXEC_COUNT, 0); + } + int64_t noexec_duration() const { + return GetField(VT_NOEXEC_DURATION, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_NOEXEC_COUNT, 8) && + VerifyField(verifier, VT_NOEXEC_DURATION, 8) && + verifier.EndTable(); + } + StatsMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(StatsMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatsMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct StatsMessageBuilder { + typedef StatsMessage Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_noexec_count(int64_t noexec_count) { + fbb_.AddElement(StatsMessage::VT_NOEXEC_COUNT, noexec_count, 0); + } + void add_noexec_duration(int64_t noexec_duration) { + fbb_.AddElement(StatsMessage::VT_NOEXEC_DURATION, noexec_duration, 0); + } + explicit StatsMessageBuilder(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 CreateStatsMessage( + flatbuffers::FlatBufferBuilder &_fbb, + int64_t noexec_count = 0, + int64_t noexec_duration = 0) { + StatsMessageBuilder builder_(_fbb); + builder_.add_noexec_duration(noexec_duration); + builder_.add_noexec_count(noexec_count); + return builder_.Finish(); +} + +flatbuffers::Offset CreateStatsMessage(flatbuffers::FlatBufferBuilder &_fbb, const StatsMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct CallInfoT : public flatbuffers::NativeTable { + typedef CallInfo TableType; + rpc::CallFlag flags = static_cast(0); + int32_t error = 0; + std::vector signal{}; + std::vector cover{}; + std::vector comps{}; +}; + +struct CallInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CallInfoT NativeTableType; + typedef CallInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_FLAGS = 4, + VT_ERROR = 6, + VT_SIGNAL = 8, + VT_COVER = 10, + VT_COMPS = 12 + }; + rpc::CallFlag flags() const { + return static_cast(GetField(VT_FLAGS, 0)); + } + int32_t error() const { + return GetField(VT_ERROR, 0); + } + const flatbuffers::Vector *signal() const { + return GetPointer *>(VT_SIGNAL); + } + const flatbuffers::Vector *cover() const { + return GetPointer *>(VT_COVER); + } + const flatbuffers::Vector *comps() const { + return GetPointer *>(VT_COMPS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_FLAGS, 1) && + VerifyField(verifier, VT_ERROR, 4) && + VerifyOffset(verifier, VT_SIGNAL) && + verifier.VerifyVector(signal()) && + VerifyOffset(verifier, VT_COVER) && + verifier.VerifyVector(cover()) && + VerifyOffset(verifier, VT_COMPS) && + verifier.VerifyVector(comps()) && + verifier.EndTable(); + } + CallInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(CallInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct CallInfoBuilder { + typedef CallInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_flags(rpc::CallFlag flags) { + fbb_.AddElement(CallInfo::VT_FLAGS, static_cast(flags), 0); + } + void add_error(int32_t error) { + fbb_.AddElement(CallInfo::VT_ERROR, error, 0); + } + void add_signal(flatbuffers::Offset> signal) { + fbb_.AddOffset(CallInfo::VT_SIGNAL, signal); + } + void add_cover(flatbuffers::Offset> cover) { + fbb_.AddOffset(CallInfo::VT_COVER, cover); + } + void add_comps(flatbuffers::Offset> comps) { + fbb_.AddOffset(CallInfo::VT_COMPS, comps); + } + explicit CallInfoBuilder(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 CreateCallInfo( + flatbuffers::FlatBufferBuilder &_fbb, + rpc::CallFlag flags = static_cast(0), + int32_t error = 0, + flatbuffers::Offset> signal = 0, + flatbuffers::Offset> cover = 0, + flatbuffers::Offset> comps = 0) { + CallInfoBuilder builder_(_fbb); + builder_.add_comps(comps); + builder_.add_cover(cover); + builder_.add_signal(signal); + builder_.add_error(error); + builder_.add_flags(flags); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateCallInfoDirect( + flatbuffers::FlatBufferBuilder &_fbb, + rpc::CallFlag flags = static_cast(0), + int32_t error = 0, + const std::vector *signal = nullptr, + const std::vector *cover = nullptr, + const std::vector *comps = nullptr) { + auto signal__ = signal ? _fbb.CreateVector(*signal) : 0; + auto cover__ = cover ? _fbb.CreateVector(*cover) : 0; + auto comps__ = comps ? _fbb.CreateVectorOfStructs(*comps) : 0; + return rpc::CreateCallInfo( + _fbb, + flags, + error, + signal__, + cover__, + comps__); +} + +flatbuffers::Offset CreateCallInfo(flatbuffers::FlatBufferBuilder &_fbb, const CallInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ProgInfoT : public flatbuffers::NativeTable { + typedef ProgInfo TableType; + std::vector> calls{}; + std::unique_ptr extra{}; + uint64_t elapsed = 0; + uint64_t freshness = 0; + ProgInfoT() = default; + ProgInfoT(const ProgInfoT &o); + ProgInfoT(ProgInfoT&&) FLATBUFFERS_NOEXCEPT = default; + ProgInfoT &operator=(ProgInfoT o) FLATBUFFERS_NOEXCEPT; +}; + +struct ProgInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ProgInfoT NativeTableType; + typedef ProgInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_CALLS = 4, + VT_EXTRA = 6, + VT_ELAPSED = 8, + VT_FRESHNESS = 10 + }; + const flatbuffers::Vector> *calls() const { + return GetPointer> *>(VT_CALLS); + } + const rpc::CallInfo *extra() const { + return GetPointer(VT_EXTRA); + } + uint64_t elapsed() const { + return GetField(VT_ELAPSED, 0); + } + uint64_t freshness() const { + return GetField(VT_FRESHNESS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_CALLS) && + verifier.VerifyVector(calls()) && + verifier.VerifyVectorOfTables(calls()) && + VerifyOffset(verifier, VT_EXTRA) && + verifier.VerifyTable(extra()) && + VerifyField(verifier, VT_ELAPSED, 8) && + VerifyField(verifier, VT_FRESHNESS, 8) && + verifier.EndTable(); + } + ProgInfoT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ProgInfoT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ProgInfoBuilder { + typedef ProgInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_calls(flatbuffers::Offset>> calls) { + fbb_.AddOffset(ProgInfo::VT_CALLS, calls); + } + void add_extra(flatbuffers::Offset extra) { + fbb_.AddOffset(ProgInfo::VT_EXTRA, extra); + } + void add_elapsed(uint64_t elapsed) { + fbb_.AddElement(ProgInfo::VT_ELAPSED, elapsed, 0); + } + void add_freshness(uint64_t freshness) { + fbb_.AddElement(ProgInfo::VT_FRESHNESS, freshness, 0); + } + explicit ProgInfoBuilder(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 CreateProgInfo( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset>> calls = 0, + flatbuffers::Offset extra = 0, + uint64_t elapsed = 0, + uint64_t freshness = 0) { + ProgInfoBuilder builder_(_fbb); + builder_.add_freshness(freshness); + builder_.add_elapsed(elapsed); + builder_.add_extra(extra); + builder_.add_calls(calls); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateProgInfoDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector> *calls = nullptr, + flatbuffers::Offset extra = 0, + uint64_t elapsed = 0, + uint64_t freshness = 0) { + auto calls__ = calls ? _fbb.CreateVector>(*calls) : 0; + return rpc::CreateProgInfo( + _fbb, + calls__, + extra, + elapsed, + freshness); +} + +flatbuffers::Offset CreateProgInfo(flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ExecResultT : public flatbuffers::NativeTable { + typedef ExecResult TableType; + std::unique_ptr executing{}; + std::vector output{}; + std::string error{}; + std::unique_ptr info{}; + ExecResultT() = default; + ExecResultT(const ExecResultT &o); + ExecResultT(ExecResultT&&) FLATBUFFERS_NOEXCEPT = default; + ExecResultT &operator=(ExecResultT o) FLATBUFFERS_NOEXCEPT; +}; + +struct ExecResult FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ExecResultT NativeTableType; + typedef ExecResultBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_EXECUTING = 4, + VT_OUTPUT = 6, + VT_ERROR = 8, + VT_INFO = 10 + }; + const rpc::ExecutingMessage *executing() const { + return GetPointer(VT_EXECUTING); + } + const flatbuffers::Vector *output() const { + return GetPointer *>(VT_OUTPUT); + } + const flatbuffers::String *error() const { + return GetPointer(VT_ERROR); + } + const rpc::ProgInfo *info() const { + return GetPointer(VT_INFO); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_EXECUTING) && + verifier.VerifyTable(executing()) && + VerifyOffset(verifier, VT_OUTPUT) && + verifier.VerifyVector(output()) && + VerifyOffset(verifier, VT_ERROR) && + verifier.VerifyString(error()) && + VerifyOffset(verifier, VT_INFO) && + verifier.VerifyTable(info()) && + verifier.EndTable(); + } + ExecResultT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ExecResultT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; + static flatbuffers::Offset Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecResultT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ExecResultBuilder { + typedef ExecResult Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_executing(flatbuffers::Offset executing) { + fbb_.AddOffset(ExecResult::VT_EXECUTING, executing); + } + void add_output(flatbuffers::Offset> output) { + fbb_.AddOffset(ExecResult::VT_OUTPUT, output); + } + void add_error(flatbuffers::Offset error) { + fbb_.AddOffset(ExecResult::VT_ERROR, error); + } + void add_info(flatbuffers::Offset info) { + fbb_.AddOffset(ExecResult::VT_INFO, info); + } + explicit ExecResultBuilder(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 CreateExecResult( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset executing = 0, + flatbuffers::Offset> output = 0, + flatbuffers::Offset error = 0, + flatbuffers::Offset info = 0) { + ExecResultBuilder builder_(_fbb); + builder_.add_info(info); + builder_.add_error(error); + builder_.add_output(output); + builder_.add_executing(executing); + return builder_.Finish(); +} + +inline flatbuffers::Offset CreateExecResultDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset executing = 0, + const std::vector *output = nullptr, + const char *error = nullptr, + flatbuffers::Offset info = 0) { + auto output__ = output ? _fbb.CreateVector(*output) : 0; + auto error__ = error ? _fbb.CreateString(error) : 0; + return rpc::CreateExecResult( + _fbb, + executing, + output__, + error__, + info); +} + +flatbuffers::Offset CreateExecResult(flatbuffers::FlatBufferBuilder &_fbb, const ExecResultT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); + +inline ConnectRequestT *ConnectRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ConnectRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ConnectRequest::UnPackTo(ConnectRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = name(); if (_e) _o->name = _e->str(); } + { auto _e = arch(); if (_e) _o->arch = _e->str(); } + { auto _e = git_revision(); if (_e) _o->git_revision = _e->str(); } + { auto _e = syz_revision(); if (_e) _o->syz_revision = _e->str(); } +} + +inline flatbuffers::Offset ConnectRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateConnectRequest(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateConnectRequest(flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConnectRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); + auto _arch = _o->arch.empty() ? 0 : _fbb.CreateString(_o->arch); + auto _git_revision = _o->git_revision.empty() ? 0 : _fbb.CreateString(_o->git_revision); + auto _syz_revision = _o->syz_revision.empty() ? 0 : _fbb.CreateString(_o->syz_revision); + return rpc::CreateConnectRequest( + _fbb, + _name, + _arch, + _git_revision, + _syz_revision); +} + +inline ConnectReplyT *ConnectReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ConnectReplyT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ConnectReply::UnPackTo(ConnectReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = leak_frames(); if (_e) { _o->leak_frames.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->leak_frames[_i] = _e->Get(_i)->str(); } } } + { auto _e = race_frames(); if (_e) { _o->race_frames.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->race_frames[_i] = _e->Get(_i)->str(); } } } + { auto _e = features(); _o->features = _e; } + { auto _e = files(); if (_e) { _o->files.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->files[_i] = _e->Get(_i)->str(); } } } + { auto _e = globs(); if (_e) { _o->globs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->globs[_i] = _e->Get(_i)->str(); } } } +} + +inline flatbuffers::Offset ConnectReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateConnectReply(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateConnectReply(flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ConnectReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _leak_frames = _o->leak_frames.size() ? _fbb.CreateVectorOfStrings(_o->leak_frames) : 0; + auto _race_frames = _o->race_frames.size() ? _fbb.CreateVectorOfStrings(_o->race_frames) : 0; + auto _features = _o->features; + auto _files = _o->files.size() ? _fbb.CreateVectorOfStrings(_o->files) : 0; + auto _globs = _o->globs.size() ? _fbb.CreateVectorOfStrings(_o->globs) : 0; + return rpc::CreateConnectReply( + _fbb, + _leak_frames, + _race_frames, + _features, + _files, + _globs); +} + +inline InfoRequestT::InfoRequestT(const InfoRequestT &o) + : error(o.error), + features(o.features) { + globs.reserve(o.globs.size()); + for (const auto &globs_ : o.globs) { globs.emplace_back((globs_) ? new rpc::GlobInfoT(*globs_) : nullptr); } + files.reserve(o.files.size()); + for (const auto &files_ : o.files) { files.emplace_back((files_) ? new rpc::FileInfoT(*files_) : nullptr); } +} + +inline InfoRequestT &InfoRequestT::operator=(InfoRequestT o) FLATBUFFERS_NOEXCEPT { + std::swap(error, o.error); + std::swap(features, o.features); + std::swap(globs, o.globs); + std::swap(files, o.files); + return *this; +} + +inline InfoRequestT *InfoRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new InfoRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void InfoRequest::UnPackTo(InfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = error(); if (_e) _o->error = _e->str(); } + { auto _e = features(); _o->features = _e; } + { auto _e = globs(); if (_e) { _o->globs.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->globs[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } } + { auto _e = files(); if (_e) { _o->files.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->files[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } } +} + +inline flatbuffers::Offset InfoRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateInfoRequest(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InfoRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _error = _o->error.empty() ? 0 : _fbb.CreateString(_o->error); + auto _features = _o->features; + auto _globs = _o->globs.size() ? _fbb.CreateVector> (_o->globs.size(), [](size_t i, _VectorArgs *__va) { return CreateGlobInfo(*__va->__fbb, __va->__o->globs[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _files = _o->files.size() ? _fbb.CreateVector> (_o->files.size(), [](size_t i, _VectorArgs *__va) { return CreateFileInfo(*__va->__fbb, __va->__o->files[i].get(), __va->__rehasher); }, &_va ) : 0; + return rpc::CreateInfoRequest( + _fbb, + _error, + _features, + _globs, + _files); +} + +inline InfoReplyT *InfoReply::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new InfoReplyT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void InfoReply::UnPackTo(InfoReplyT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = cover_filter(); if (_e) { _o->cover_filter.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->cover_filter[_i] = _e->Get(_i); } } } +} + +inline flatbuffers::Offset InfoReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateInfoReply(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateInfoReply(flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const InfoReplyT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _cover_filter = _o->cover_filter.size() ? _fbb.CreateVector(_o->cover_filter) : 0; + return rpc::CreateInfoReply( + _fbb, + _cover_filter); +} + +inline FileInfoT *FileInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new FileInfoT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void FileInfo::UnPackTo(FileInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = name(); if (_e) _o->name = _e->str(); } + { auto _e = exists(); _o->exists = _e; } + { auto _e = error(); if (_e) _o->error = _e->str(); } + { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } +} + +inline flatbuffers::Offset FileInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FileInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateFileInfo(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateFileInfo(flatbuffers::FlatBufferBuilder &_fbb, const FileInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FileInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); + auto _exists = _o->exists; + auto _error = _o->error.empty() ? 0 : _fbb.CreateString(_o->error); + auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; + return rpc::CreateFileInfo( + _fbb, + _name, + _exists, + _error, + _data); +} + +inline GlobInfoT *GlobInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new GlobInfoT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void GlobInfo::UnPackTo(GlobInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = name(); if (_e) _o->name = _e->str(); } + { auto _e = files(); if (_e) { _o->files.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->files[_i] = _e->Get(_i)->str(); } } } +} + +inline flatbuffers::Offset GlobInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateGlobInfo(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateGlobInfo(flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const GlobInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); + auto _files = _o->files.size() ? _fbb.CreateVectorOfStrings(_o->files) : 0; + return rpc::CreateGlobInfo( + _fbb, + _name, + _files); +} + +inline HostMessageT *HostMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new HostMessageT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void HostMessage::UnPackTo(HostMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = msg_type(); _o->msg.type = _e; } + { auto _e = msg(); if (_e) _o->msg.value = rpc::HostMessagesUnion::UnPack(_e, msg_type(), _resolver); } +} + +inline flatbuffers::Offset HostMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateHostMessage(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateHostMessage(flatbuffers::FlatBufferBuilder &_fbb, const HostMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const HostMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _msg_type = _o->msg.type; + auto _msg = _o->msg.Pack(_fbb); + return rpc::CreateHostMessage( + _fbb, + _msg_type, + _msg); +} + +inline ExecutorMessageT *ExecutorMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ExecutorMessageT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ExecutorMessage::UnPackTo(ExecutorMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = msg_type(); _o->msg.type = _e; } + { auto _e = msg(); if (_e) _o->msg.value = rpc::ExecutorMessagesUnion::UnPack(_e, msg_type(), _resolver); } +} + +inline flatbuffers::Offset ExecutorMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateExecutorMessage(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateExecutorMessage(flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExecutorMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _msg_type = _o->msg.type; + auto _msg = _o->msg.Pack(_fbb); + return rpc::CreateExecutorMessage( + _fbb, + _msg_type, + _msg); +} + +inline ExecRequestT *ExecRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ExecRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ExecRequest::UnPackTo(ExecRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); _o->id = _e; } + { auto _e = prog_data(); if (_e) { _o->prog_data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->prog_data.begin()); } } + { auto _e = flags(); _o->flags = _e; } + { auto _e = exec_env(); _o->exec_env = _e; } + { auto _e = exec_flags(); _o->exec_flags = _e; } + { auto _e = sandbox_arg(); _o->sandbox_arg = _e; } + { auto _e = signal_filter(); if (_e) { _o->signal_filter.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->signal_filter[_i] = _e->Get(_i); } } } + { auto _e = signal_filter_call(); _o->signal_filter_call = _e; } + { auto _e = repeat(); _o->repeat = _e; } +} + +inline flatbuffers::Offset ExecRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateExecRequest(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateExecRequest(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExecRequestT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id; + auto _prog_data = _o->prog_data.size() ? _fbb.CreateVector(_o->prog_data) : 0; + auto _flags = _o->flags; + auto _exec_env = _o->exec_env; + auto _exec_flags = _o->exec_flags; + auto _sandbox_arg = _o->sandbox_arg; + auto _signal_filter = _o->signal_filter.size() ? _fbb.CreateVector(_o->signal_filter) : 0; + auto _signal_filter_call = _o->signal_filter_call; + auto _repeat = _o->repeat; + return rpc::CreateExecRequest( + _fbb, + _id, + _prog_data, + _flags, + _exec_env, + _exec_flags, + _sandbox_arg, + _signal_filter, + _signal_filter_call, + _repeat); +} + +inline SignalUpdateT *SignalUpdate::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new SignalUpdateT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void SignalUpdate::UnPackTo(SignalUpdateT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = new_max(); if (_e) { _o->new_max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->new_max[_i] = _e->Get(_i); } } } + { auto _e = drop_max(); if (_e) { _o->drop_max.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->drop_max[_i] = _e->Get(_i); } } } +} + +inline flatbuffers::Offset SignalUpdate::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateSignalUpdate(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateSignalUpdate(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const SignalUpdateT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _new_max = _o->new_max.size() ? _fbb.CreateVector(_o->new_max) : 0; + auto _drop_max = _o->drop_max.size() ? _fbb.CreateVector(_o->drop_max) : 0; + return rpc::CreateSignalUpdate( + _fbb, + _new_max, + _drop_max); +} + +inline ExecutingMessageT *ExecutingMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ExecutingMessageT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ExecutingMessage::UnPackTo(ExecutingMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = id(); _o->id = _e; } + { auto _e = proc_id(); _o->proc_id = _e; } + { auto _e = try_(); _o->try_ = _e; } +} + +inline flatbuffers::Offset ExecutingMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateExecutingMessage(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateExecutingMessage(flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExecutingMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _id = _o->id; + auto _proc_id = _o->proc_id; + auto _try_ = _o->try_; + return rpc::CreateExecutingMessage( + _fbb, + _id, + _proc_id, + _try_); +} + +inline StatsMessageT *StatsMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new StatsMessageT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void StatsMessage::UnPackTo(StatsMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = noexec_count(); _o->noexec_count = _e; } + { auto _e = noexec_duration(); _o->noexec_duration = _e; } +} + +inline flatbuffers::Offset StatsMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatsMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateStatsMessage(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateStatsMessage(flatbuffers::FlatBufferBuilder &_fbb, const StatsMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const StatsMessageT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _noexec_count = _o->noexec_count; + auto _noexec_duration = _o->noexec_duration; + return rpc::CreateStatsMessage( + _fbb, + _noexec_count, + _noexec_duration); +} + +inline CallInfoT *CallInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new CallInfoT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void CallInfo::UnPackTo(CallInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = flags(); _o->flags = _e; } + { auto _e = error(); _o->error = _e; } + { auto _e = signal(); if (_e) { _o->signal.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->signal[_i] = _e->Get(_i); } } } + { auto _e = cover(); if (_e) { _o->cover.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->cover[_i] = _e->Get(_i); } } } + { auto _e = comps(); if (_e) { _o->comps.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->comps[_i] = *_e->Get(_i); } } } +} + +inline flatbuffers::Offset CallInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateCallInfo(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateCallInfo(flatbuffers::FlatBufferBuilder &_fbb, const CallInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const CallInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _flags = _o->flags; + auto _error = _o->error; + auto _signal = _o->signal.size() ? _fbb.CreateVector(_o->signal) : 0; + auto _cover = _o->cover.size() ? _fbb.CreateVector(_o->cover) : 0; + auto _comps = _o->comps.size() ? _fbb.CreateVectorOfStructs(_o->comps) : 0; + return rpc::CreateCallInfo( + _fbb, + _flags, + _error, + _signal, + _cover, + _comps); +} + +inline ProgInfoT::ProgInfoT(const ProgInfoT &o) + : extra((o.extra) ? new rpc::CallInfoT(*o.extra) : nullptr), + elapsed(o.elapsed), + freshness(o.freshness) { + calls.reserve(o.calls.size()); + for (const auto &calls_ : o.calls) { calls.emplace_back((calls_) ? new rpc::CallInfoT(*calls_) : nullptr); } +} + +inline ProgInfoT &ProgInfoT::operator=(ProgInfoT o) FLATBUFFERS_NOEXCEPT { + std::swap(calls, o.calls); + std::swap(extra, o.extra); + std::swap(elapsed, o.elapsed); + std::swap(freshness, o.freshness); + return *this; +} + +inline ProgInfoT *ProgInfo::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ProgInfoT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ProgInfo::UnPackTo(ProgInfoT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = calls(); if (_e) { _o->calls.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->calls[_i] = std::unique_ptr(_e->Get(_i)->UnPack(_resolver)); } } } + { auto _e = extra(); if (_e) _o->extra = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = elapsed(); _o->elapsed = _e; } + { auto _e = freshness(); _o->freshness = _e; } +} + +inline flatbuffers::Offset ProgInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateProgInfo(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateProgInfo(flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ProgInfoT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _calls = _o->calls.size() ? _fbb.CreateVector> (_o->calls.size(), [](size_t i, _VectorArgs *__va) { return CreateCallInfo(*__va->__fbb, __va->__o->calls[i].get(), __va->__rehasher); }, &_va ) : 0; + auto _extra = _o->extra ? CreateCallInfo(_fbb, _o->extra.get(), _rehasher) : 0; + auto _elapsed = _o->elapsed; + auto _freshness = _o->freshness; + return rpc::CreateProgInfo( + _fbb, + _calls, + _extra, + _elapsed, + _freshness); +} + +inline ExecResultT::ExecResultT(const ExecResultT &o) + : executing((o.executing) ? new rpc::ExecutingMessageT(*o.executing) : nullptr), + output(o.output), + error(o.error), + info((o.info) ? new rpc::ProgInfoT(*o.info) : nullptr) { +} + +inline ExecResultT &ExecResultT::operator=(ExecResultT o) FLATBUFFERS_NOEXCEPT { + std::swap(executing, o.executing); + std::swap(output, o.output); + std::swap(error, o.error); + std::swap(info, o.info); + return *this; +} + +inline ExecResultT *ExecResult::UnPack(const flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ExecResultT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ExecResult::UnPackTo(ExecResultT *_o, const flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = executing(); if (_e) _o->executing = std::unique_ptr(_e->UnPack(_resolver)); } + { auto _e = output(); if (_e) { _o->output.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->output.begin()); } } + { auto _e = error(); if (_e) _o->error = _e->str(); } + { auto _e = info(); if (_e) _o->info = std::unique_ptr(_e->UnPack(_resolver)); } +} + +inline flatbuffers::Offset ExecResult::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecResultT* _o, const flatbuffers::rehasher_function_t *_rehasher) { + return CreateExecResult(_fbb, _o, _rehasher); +} + +inline flatbuffers::Offset CreateExecResult(flatbuffers::FlatBufferBuilder &_fbb, const ExecResultT *_o, const flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ExecResultT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _executing = _o->executing ? CreateExecutingMessage(_fbb, _o->executing.get(), _rehasher) : 0; + auto _output = _o->output.size() ? _fbb.CreateVector(_o->output) : 0; + auto _error = _o->error.empty() ? 0 : _fbb.CreateString(_o->error); + auto _info = _o->info ? CreateProgInfo(_fbb, _o->info.get(), _rehasher) : 0; + return rpc::CreateExecResult( + _fbb, + _executing, + _output, + _error, + _info); +} + +inline bool VerifyHostMessages(flatbuffers::Verifier &verifier, const void *obj, HostMessages type) { + switch (type) { + case HostMessages::NONE: { + return true; + } + case HostMessages::ExecRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case HostMessages::SignalUpdate: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyHostMessagesVector(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 (!VerifyHostMessages( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *HostMessagesUnion::UnPack(const void *obj, HostMessages type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case HostMessages::ExecRequest: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case HostMessages::SignalUpdate: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset HostMessagesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case HostMessages::ExecRequest: { + auto ptr = reinterpret_cast(value); + return CreateExecRequest(_fbb, ptr, _rehasher).Union(); + } + case HostMessages::SignalUpdate: { + auto ptr = reinterpret_cast(value); + return CreateSignalUpdate(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline HostMessagesUnion::HostMessagesUnion(const HostMessagesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case HostMessages::ExecRequest: { + value = new rpc::ExecRequestT(*reinterpret_cast(u.value)); + break; + } + case HostMessages::SignalUpdate: { + value = new rpc::SignalUpdateT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void HostMessagesUnion::Reset() { + switch (type) { + case HostMessages::ExecRequest: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case HostMessages::SignalUpdate: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = HostMessages::NONE; +} + +inline bool VerifyExecutorMessages(flatbuffers::Verifier &verifier, const void *obj, ExecutorMessages type) { + switch (type) { + case ExecutorMessages::NONE: { + return true; + } + case ExecutorMessages::ExecResult: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ExecutorMessages::Executing: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case ExecutorMessages::Stats: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyExecutorMessagesVector(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 (!VerifyExecutorMessages( + verifier, values->Get(i), types->GetEnum(i))) { + return false; + } + } + return true; +} + +inline void *ExecutorMessagesUnion::UnPack(const void *obj, ExecutorMessages type, const flatbuffers::resolver_function_t *resolver) { + (void)resolver; + switch (type) { + case ExecutorMessages::ExecResult: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case ExecutorMessages::Executing: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case ExecutorMessages::Stats: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + default: return nullptr; + } +} + +inline flatbuffers::Offset ExecutorMessagesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { + (void)_rehasher; + switch (type) { + case ExecutorMessages::ExecResult: { + auto ptr = reinterpret_cast(value); + return CreateExecResult(_fbb, ptr, _rehasher).Union(); + } + case ExecutorMessages::Executing: { + auto ptr = reinterpret_cast(value); + return CreateExecutingMessage(_fbb, ptr, _rehasher).Union(); + } + case ExecutorMessages::Stats: { + auto ptr = reinterpret_cast(value); + return CreateStatsMessage(_fbb, ptr, _rehasher).Union(); + } + default: return 0; + } +} + +inline ExecutorMessagesUnion::ExecutorMessagesUnion(const ExecutorMessagesUnion &u) : type(u.type), value(nullptr) { + switch (type) { + case ExecutorMessages::ExecResult: { + value = new rpc::ExecResultT(*reinterpret_cast(u.value)); + break; + } + case ExecutorMessages::Executing: { + value = new rpc::ExecutingMessageT(*reinterpret_cast(u.value)); + break; + } + case ExecutorMessages::Stats: { + value = new rpc::StatsMessageT(*reinterpret_cast(u.value)); + break; + } + default: + break; + } +} + +inline void ExecutorMessagesUnion::Reset() { + switch (type) { + case ExecutorMessages::ExecResult: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case ExecutorMessages::Executing: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case ExecutorMessages::Stats: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + default: break; + } + value = nullptr; + type = ExecutorMessages::NONE; +} + +} // namespace rpc + +#endif // FLATBUFFERS_GENERATED_FLATRPC_RPC_H_ -- cgit mrf-deployment