aboutsummaryrefslogtreecommitdiffstats
path: root/pkg
diff options
context:
space:
mode:
Diffstat (limited to 'pkg')
-rw-r--r--pkg/flatrpc/flatrpc.fbs208
-rw-r--r--pkg/flatrpc/flatrpc.go2732
-rw-r--r--pkg/flatrpc/flatrpc.h2835
3 files changed, 5775 insertions, 0 deletions
diff --git a/pkg/flatrpc/flatrpc.fbs b/pkg/flatrpc/flatrpc.fbs
new file mode 100644
index 000000000..ac57f7425
--- /dev/null
+++ b/pkg/flatrpc/flatrpc.fbs
@@ -0,0 +1,208 @@
+// Copyright 2024 syzkaller project authors. All rights reserved.
+// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
+
+namespace rpc;
+
+enum Feature : uint64 (bit_flags) {
+ Coverage,
+ Comparisons,
+ ExtraCoverage,
+ DelayKcovMmap,
+ SandboxSetuid,
+ SandboxNamespace,
+ SandboxAndroid,
+ Fault,
+ Leak,
+ NetInjection,
+ NetDevices,
+ KCSAN,
+ DevlinkPCI,
+ NicVF,
+ USBEmulation,
+ VhciInjection,
+ WifiEmulation,
+ LRWPANEmulation, // 802.15.4 standard
+ BinFmtMisc,
+ Swap,
+}
+
+table ConnectRequest {
+ name :string;
+ arch :string;
+ git_revision :string;
+ syz_revision :string;
+}
+
+table ConnectReply {
+ leak_frames :[string];
+ race_frames :[string];
+ // Features are forwarded from CheckArgs, if checking was already done.
+ features :Feature;
+ // Fuzzer reads these files inside of the VM and returns contents in CheckArgs.Files.
+ files :[string];
+ globs :[string];
+}
+
+table InfoRequest {
+ error :string;
+ features :Feature;
+ globs :[GlobInfo];
+ files :[FileInfo];
+}
+
+table InfoReply {
+ cover_filter :[uint32];
+}
+
+table FileInfo {
+ name :string;
+ exists :bool;
+ error :string;
+ data :[uint8];
+}
+
+table GlobInfo {
+ name :string;
+ files :[string];
+}
+
+// Messages sent from the host to the executor.
+union HostMessages {
+ ExecRequest :ExecRequest,
+ SignalUpdate :SignalUpdate,
+}
+
+table HostMessage {
+ msg :HostMessages;
+}
+
+// Messages sent from the executor to the host.
+union ExecutorMessages {
+ ExecResult :ExecResult,
+ Executing :ExecutingMessage,
+ Stats :StatsMessage,
+}
+
+table ExecutorMessage {
+ msg :ExecutorMessages;
+}
+
+enum RequestFlag : uint64 (bit_flags) {
+ // If set, prog_data contains compiled executable binary
+ // that needs to be written to disk and executed.
+ IsBinary,
+ // Return only new signal rather than all signal.
+ NewSignal,
+ // If set, fully reset executor state befor executing the test.
+ ResetState,
+ // If set, collect program output and return in output field.
+ ReturnOutput,
+ // If set, don't fail on program failures, instead return the error in error field.
+ ReturnError,
+}
+
+// Note: New / changed flags should be added to parse_env_flags in executor.cc.
+enum ExecEnv : uint64 (bit_flags) {
+ Debug, // debug output from executor
+ Signal, // collect feedback signals (coverage)
+ SandboxSetuid, // impersonate nobody user
+ SandboxNamespace, // use namespaces for sandboxing
+ SandboxAndroid, // use Android sandboxing for the untrusted_app domain
+ ExtraCover, // collect extra coverage
+ EnableTun, // setup and use /dev/tun for packet injection
+ EnableNetDev, // setup more network devices for testing
+ EnableNetReset, // reset network namespace between programs
+ EnableCgroups, // setup cgroups for testing
+ EnableCloseFds, // close fds after each program
+ EnableDevlinkPCI, // setup devlink PCI device
+ EnableVhciInjection, // setup and use /dev/vhci for hci packet injection
+ EnableWifi, // setup and use mac80211_hwsim for wifi emulation
+ DelayKcovMmap, // manage kcov memory in an optimized way
+ EnableNicVF, // setup NIC VF device
+}
+
+enum ExecFlag : uint64 (bit_flags) {
+ CollectSignal, // collect feedback signals
+ CollectCover, // collect coverage
+ DedupCover, // deduplicate coverage in executor
+ CollectComps, // collect KCOV comparisons
+ Threaded, // use multiple threads to mitigate blocked syscalls
+ CoverFilter, // setup and use bitmap to do coverage filter
+}
+
+// Request to execute a test program.
+table ExecRequest {
+ id :int64;
+ prog_data :[uint8];
+ flags :RequestFlag;
+ exec_env :ExecEnv;
+ exec_flags :ExecFlag;
+ sandbox_arg :int64;
+ signal_filter :[uint32];
+ signal_filter_call :int32;
+ // Repeat the program that many times (0 means 1).
+ repeat :int32;
+}
+
+table SignalUpdate {
+ new_max :[uint32];
+ drop_max :[uint32];
+}
+
+// Notification from the executor that it started executing the program 'id'.
+// We want this request to be as small and as fast as possible b/c we need it
+// to reach the host (or at least leave the VM) before the VM crashes
+// executing this program.
+table ExecutingMessage {
+ id :int64;
+ proc_id :int32;
+ try :int32;
+}
+
+table StatsMessage {
+ noexec_count :int64;
+ noexec_duration :int64;
+}
+
+enum CallFlag : uint8 (bit_flags) {
+ Executed, // was started at all
+ Finished, // finished executing (rather than blocked forever)
+ Blocked, // finished but blocked during execution
+ FaultInjected, // fault was injected into this call
+}
+
+table CallInfo {
+ flags :CallFlag;
+ // Call errno (0 if the call was successful).
+ error :int32;
+ // Feedback signal, filled if ExecFlag.CollectSignal is set.
+ signal :[uint32];
+ // Code coverage, filled if ExecFlag.CollectCover is set.
+ // If ExecFlag.DedupCover is set, then duplicates are removed, otherwise it contains a trace.
+ cover :[uint32];
+ // Comparison operands.
+ comps :[Comparison];
+}
+
+struct Comparison {
+ op1 :uint64;
+ op2 :uint64;
+}
+
+table ProgInfo {
+ calls :[CallInfo];
+ // Contains signal and cover collected from background threads.
+ extra :CallInfo;
+ // Total execution time of the program in nanoseconds.
+ elapsed :uint64;
+ // Number of programs executed in the same process before this one.
+ freshness :uint64;
+}
+
+// Result of executing a test program.
+table ExecResult {
+ executing :ExecutingMessage;
+ output :[uint8];
+ error :string;
+ info :ProgInfo;
+}
diff --git a/pkg/flatrpc/flatrpc.go b/pkg/flatrpc/flatrpc.go
new file mode 100644
index 000000000..cdc69ba58
--- /dev/null
+++ b/pkg/flatrpc/flatrpc.go
@@ -0,0 +1,2732 @@
+// Code generated by the FlatBuffers compiler. DO NOT EDIT.
+
+package flatrpc
+
+import (
+ "strconv"
+
+ flatbuffers "github.com/google/flatbuffers/go"
+)
+
+type Feature uint64
+
+const (
+ FeatureCoverage Feature = 1
+ FeatureComparisons Feature = 2
+ FeatureExtraCoverage Feature = 4
+ FeatureDelayKcovMmap Feature = 8
+ FeatureSandboxSetuid Feature = 16
+ FeatureSandboxNamespace Feature = 32
+ FeatureSandboxAndroid Feature = 64
+ FeatureFault Feature = 128
+ FeatureLeak Feature = 256
+ FeatureNetInjection Feature = 512
+ FeatureNetDevices Feature = 1024
+ FeatureKCSAN Feature = 2048
+ FeatureDevlinkPCI Feature = 4096
+ FeatureNicVF Feature = 8192
+ FeatureUSBEmulation Feature = 16384
+ FeatureVhciInjection Feature = 32768
+ FeatureWifiEmulation Feature = 65536
+ FeatureLRWPANEmulation Feature = 131072
+ FeatureBinFmtMisc Feature = 262144
+ FeatureSwap Feature = 524288
+)
+
+var EnumNamesFeature = map[Feature]string{
+ FeatureCoverage: "Coverage",
+ FeatureComparisons: "Comparisons",
+ FeatureExtraCoverage: "ExtraCoverage",
+ FeatureDelayKcovMmap: "DelayKcovMmap",
+ FeatureSandboxSetuid: "SandboxSetuid",
+ FeatureSandboxNamespace: "SandboxNamespace",
+ FeatureSandboxAndroid: "SandboxAndroid",
+ FeatureFault: "Fault",
+ FeatureLeak: "Leak",
+ FeatureNetInjection: "NetInjection",
+ FeatureNetDevices: "NetDevices",
+ FeatureKCSAN: "KCSAN",
+ FeatureDevlinkPCI: "DevlinkPCI",
+ FeatureNicVF: "NicVF",
+ FeatureUSBEmulation: "USBEmulation",
+ FeatureVhciInjection: "VhciInjection",
+ FeatureWifiEmulation: "WifiEmulation",
+ FeatureLRWPANEmulation: "LRWPANEmulation",
+ FeatureBinFmtMisc: "BinFmtMisc",
+ FeatureSwap: "Swap",
+}
+
+var EnumValuesFeature = map[string]Feature{
+ "Coverage": FeatureCoverage,
+ "Comparisons": FeatureComparisons,
+ "ExtraCoverage": FeatureExtraCoverage,
+ "DelayKcovMmap": FeatureDelayKcovMmap,
+ "SandboxSetuid": FeatureSandboxSetuid,
+ "SandboxNamespace": FeatureSandboxNamespace,
+ "SandboxAndroid": FeatureSandboxAndroid,
+ "Fault": FeatureFault,
+ "Leak": FeatureLeak,
+ "NetInjection": FeatureNetInjection,
+ "NetDevices": FeatureNetDevices,
+ "KCSAN": FeatureKCSAN,
+ "DevlinkPCI": FeatureDevlinkPCI,
+ "NicVF": FeatureNicVF,
+ "USBEmulation": FeatureUSBEmulation,
+ "VhciInjection": FeatureVhciInjection,
+ "WifiEmulation": FeatureWifiEmulation,
+ "LRWPANEmulation": FeatureLRWPANEmulation,
+ "BinFmtMisc": FeatureBinFmtMisc,
+ "Swap": FeatureSwap,
+}
+
+func (v Feature) String() string {
+ if s, ok := EnumNamesFeature[v]; ok {
+ return s
+ }
+ return "Feature(" + strconv.FormatInt(int64(v), 10) + ")"
+}
+
+type HostMessages byte
+
+const (
+ HostMessagesNONE HostMessages = 0
+ HostMessagesExecRequest HostMessages = 1
+ HostMessagesSignalUpdate HostMessages = 2
+)
+
+var EnumNamesHostMessages = map[HostMessages]string{
+ HostMessagesNONE: "NONE",
+ HostMessagesExecRequest: "ExecRequest",
+ HostMessagesSignalUpdate: "SignalUpdate",
+}
+
+var EnumValuesHostMessages = map[string]HostMessages{
+ "NONE": HostMessagesNONE,
+ "ExecRequest": HostMessagesExecRequest,
+ "SignalUpdate": HostMessagesSignalUpdate,
+}
+
+func (v HostMessages) String() string {
+ if s, ok := EnumNamesHostMessages[v]; ok {
+ return s
+ }
+ return "HostMessages(" + strconv.FormatInt(int64(v), 10) + ")"
+}
+
+type HostMessagesT struct {
+ Type HostMessages
+ Value interface{}
+}
+
+func (t *HostMessagesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ switch t.Type {
+ case HostMessagesExecRequest:
+ return t.Value.(*ExecRequestT).Pack(builder)
+ case HostMessagesSignalUpdate:
+ return t.Value.(*SignalUpdateT).Pack(builder)
+ }
+ return 0
+}
+
+func (rcv HostMessages) UnPack(table flatbuffers.Table) *HostMessagesT {
+ switch rcv {
+ case HostMessagesExecRequest:
+ x := ExecRequest{_tab: table}
+ return &HostMessagesT{Type: HostMessagesExecRequest, Value: x.UnPack()}
+ case HostMessagesSignalUpdate:
+ x := SignalUpdate{_tab: table}
+ return &HostMessagesT{Type: HostMessagesSignalUpdate, Value: x.UnPack()}
+ }
+ return nil
+}
+
+type ExecutorMessages byte
+
+const (
+ ExecutorMessagesNONE ExecutorMessages = 0
+ ExecutorMessagesExecResult ExecutorMessages = 1
+ ExecutorMessagesExecuting ExecutorMessages = 2
+ ExecutorMessagesStats ExecutorMessages = 3
+)
+
+var EnumNamesExecutorMessages = map[ExecutorMessages]string{
+ ExecutorMessagesNONE: "NONE",
+ ExecutorMessagesExecResult: "ExecResult",
+ ExecutorMessagesExecuting: "Executing",
+ ExecutorMessagesStats: "Stats",
+}
+
+var EnumValuesExecutorMessages = map[string]ExecutorMessages{
+ "NONE": ExecutorMessagesNONE,
+ "ExecResult": ExecutorMessagesExecResult,
+ "Executing": ExecutorMessagesExecuting,
+ "Stats": ExecutorMessagesStats,
+}
+
+func (v ExecutorMessages) String() string {
+ if s, ok := EnumNamesExecutorMessages[v]; ok {
+ return s
+ }
+ return "ExecutorMessages(" + strconv.FormatInt(int64(v), 10) + ")"
+}
+
+type ExecutorMessagesT struct {
+ Type ExecutorMessages
+ Value interface{}
+}
+
+func (t *ExecutorMessagesT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ switch t.Type {
+ case ExecutorMessagesExecResult:
+ return t.Value.(*ExecResultT).Pack(builder)
+ case ExecutorMessagesExecuting:
+ return t.Value.(*ExecutingMessageT).Pack(builder)
+ case ExecutorMessagesStats:
+ return t.Value.(*StatsMessageT).Pack(builder)
+ }
+ return 0
+}
+
+func (rcv ExecutorMessages) UnPack(table flatbuffers.Table) *ExecutorMessagesT {
+ switch rcv {
+ case ExecutorMessagesExecResult:
+ x := ExecResult{_tab: table}
+ return &ExecutorMessagesT{Type: ExecutorMessagesExecResult, Value: x.UnPack()}
+ case ExecutorMessagesExecuting:
+ x := ExecutingMessage{_tab: table}
+ return &ExecutorMessagesT{Type: ExecutorMessagesExecuting, Value: x.UnPack()}
+ case ExecutorMessagesStats:
+ x := StatsMessage{_tab: table}
+ return &ExecutorMessagesT{Type: ExecutorMessagesStats, Value: x.UnPack()}
+ }
+ return nil
+}
+
+type RequestFlag uint64
+
+const (
+ RequestFlagIsBinary RequestFlag = 1
+ RequestFlagNewSignal RequestFlag = 2
+ RequestFlagResetState RequestFlag = 4
+ RequestFlagReturnOutput RequestFlag = 8
+ RequestFlagReturnError RequestFlag = 16
+)
+
+var EnumNamesRequestFlag = map[RequestFlag]string{
+ RequestFlagIsBinary: "IsBinary",
+ RequestFlagNewSignal: "NewSignal",
+ RequestFlagResetState: "ResetState",
+ RequestFlagReturnOutput: "ReturnOutput",
+ RequestFlagReturnError: "ReturnError",
+}
+
+var EnumValuesRequestFlag = map[string]RequestFlag{
+ "IsBinary": RequestFlagIsBinary,
+ "NewSignal": RequestFlagNewSignal,
+ "ResetState": RequestFlagResetState,
+ "ReturnOutput": RequestFlagReturnOutput,
+ "ReturnError": RequestFlagReturnError,
+}
+
+func (v RequestFlag) String() string {
+ if s, ok := EnumNamesRequestFlag[v]; ok {
+ return s
+ }
+ return "RequestFlag(" + strconv.FormatInt(int64(v), 10) + ")"
+}
+
+type ExecEnv uint64
+
+const (
+ ExecEnvDebug ExecEnv = 1
+ ExecEnvSignal ExecEnv = 2
+ ExecEnvSandboxSetuid ExecEnv = 4
+ ExecEnvSandboxNamespace ExecEnv = 8
+ ExecEnvSandboxAndroid ExecEnv = 16
+ ExecEnvExtraCover ExecEnv = 32
+ ExecEnvEnableTun ExecEnv = 64
+ ExecEnvEnableNetDev ExecEnv = 128
+ ExecEnvEnableNetReset ExecEnv = 256
+ ExecEnvEnableCgroups ExecEnv = 512
+ ExecEnvEnableCloseFds ExecEnv = 1024
+ ExecEnvEnableDevlinkPCI ExecEnv = 2048
+ ExecEnvEnableVhciInjection ExecEnv = 4096
+ ExecEnvEnableWifi ExecEnv = 8192
+ ExecEnvDelayKcovMmap ExecEnv = 16384
+ ExecEnvEnableNicVF ExecEnv = 32768
+)
+
+var EnumNamesExecEnv = map[ExecEnv]string{
+ ExecEnvDebug: "Debug",
+ ExecEnvSignal: "Signal",
+ ExecEnvSandboxSetuid: "SandboxSetuid",
+ ExecEnvSandboxNamespace: "SandboxNamespace",
+ ExecEnvSandboxAndroid: "SandboxAndroid",
+ ExecEnvExtraCover: "ExtraCover",
+ ExecEnvEnableTun: "EnableTun",
+ ExecEnvEnableNetDev: "EnableNetDev",
+ ExecEnvEnableNetReset: "EnableNetReset",
+ ExecEnvEnableCgroups: "EnableCgroups",
+ ExecEnvEnableCloseFds: "EnableCloseFds",
+ ExecEnvEnableDevlinkPCI: "EnableDevlinkPCI",
+ ExecEnvEnableVhciInjection: "EnableVhciInjection",
+ ExecEnvEnableWifi: "EnableWifi",
+ ExecEnvDelayKcovMmap: "DelayKcovMmap",
+ ExecEnvEnableNicVF: "EnableNicVF",
+}
+
+var EnumValuesExecEnv = map[string]ExecEnv{
+ "Debug": ExecEnvDebug,
+ "Signal": ExecEnvSignal,
+ "SandboxSetuid": ExecEnvSandboxSetuid,
+ "SandboxNamespace": ExecEnvSandboxNamespace,
+ "SandboxAndroid": ExecEnvSandboxAndroid,
+ "ExtraCover": ExecEnvExtraCover,
+ "EnableTun": ExecEnvEnableTun,
+ "EnableNetDev": ExecEnvEnableNetDev,
+ "EnableNetReset": ExecEnvEnableNetReset,
+ "EnableCgroups": ExecEnvEnableCgroups,
+ "EnableCloseFds": ExecEnvEnableCloseFds,
+ "EnableDevlinkPCI": ExecEnvEnableDevlinkPCI,
+ "EnableVhciInjection": ExecEnvEnableVhciInjection,
+ "EnableWifi": ExecEnvEnableWifi,
+ "DelayKcovMmap": ExecEnvDelayKcovMmap,
+ "EnableNicVF": ExecEnvEnableNicVF,
+}
+
+func (v ExecEnv) String() string {
+ if s, ok := EnumNamesExecEnv[v]; ok {
+ return s
+ }
+ return "ExecEnv(" + strconv.FormatInt(int64(v), 10) + ")"
+}
+
+type ExecFlag uint64
+
+const (
+ ExecFlagCollectSignal ExecFlag = 1
+ ExecFlagCollectCover ExecFlag = 2
+ ExecFlagDedupCover ExecFlag = 4
+ ExecFlagCollectComps ExecFlag = 8
+ ExecFlagThreaded ExecFlag = 16
+ ExecFlagCoverFilter ExecFlag = 32
+)
+
+var EnumNamesExecFlag = map[ExecFlag]string{
+ ExecFlagCollectSignal: "CollectSignal",
+ ExecFlagCollectCover: "CollectCover",
+ ExecFlagDedupCover: "DedupCover",
+ ExecFlagCollectComps: "CollectComps",
+ ExecFlagThreaded: "Threaded",
+ ExecFlagCoverFilter: "CoverFilter",
+}
+
+var EnumValuesExecFlag = map[string]ExecFlag{
+ "CollectSignal": ExecFlagCollectSignal,
+ "CollectCover": ExecFlagCollectCover,
+ "DedupCover": ExecFlagDedupCover,
+ "CollectComps": ExecFlagCollectComps,
+ "Threaded": ExecFlagThreaded,
+ "CoverFilter": ExecFlagCoverFilter,
+}
+
+func (v ExecFlag) String() string {
+ if s, ok := EnumNamesExecFlag[v]; ok {
+ return s
+ }
+ return "ExecFlag(" + strconv.FormatInt(int64(v), 10) + ")"
+}
+
+type CallFlag byte
+
+const (
+ CallFlagExecuted CallFlag = 1
+ CallFlagFinished CallFlag = 2
+ CallFlagBlocked CallFlag = 4
+ CallFlagFaultInjected CallFlag = 8
+)
+
+var EnumNamesCallFlag = map[CallFlag]string{
+ CallFlagExecuted: "Executed",
+ CallFlagFinished: "Finished",
+ CallFlagBlocked: "Blocked",
+ CallFlagFaultInjected: "FaultInjected",
+}
+
+var EnumValuesCallFlag = map[string]CallFlag{
+ "Executed": CallFlagExecuted,
+ "Finished": CallFlagFinished,
+ "Blocked": CallFlagBlocked,
+ "FaultInjected": CallFlagFaultInjected,
+}
+
+func (v CallFlag) String() string {
+ if s, ok := EnumNamesCallFlag[v]; ok {
+ return s
+ }
+ return "CallFlag(" + strconv.FormatInt(int64(v), 10) + ")"
+}
+
+type ConnectRequestT struct {
+ Name string `json:"name"`
+ Arch string `json:"arch"`
+ GitRevision string `json:"git_revision"`
+ SyzRevision string `json:"syz_revision"`
+}
+
+func (t *ConnectRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ nameOffset := builder.CreateString(t.Name)
+ archOffset := builder.CreateString(t.Arch)
+ gitRevisionOffset := builder.CreateString(t.GitRevision)
+ syzRevisionOffset := builder.CreateString(t.SyzRevision)
+ ConnectRequestStart(builder)
+ ConnectRequestAddName(builder, nameOffset)
+ ConnectRequestAddArch(builder, archOffset)
+ ConnectRequestAddGitRevision(builder, gitRevisionOffset)
+ ConnectRequestAddSyzRevision(builder, syzRevisionOffset)
+ return ConnectRequestEnd(builder)
+}
+
+func (rcv *ConnectRequest) UnPackTo(t *ConnectRequestT) {
+ t.Name = string(rcv.Name())
+ t.Arch = string(rcv.Arch())
+ t.GitRevision = string(rcv.GitRevision())
+ t.SyzRevision = string(rcv.SyzRevision())
+}
+
+func (rcv *ConnectRequest) UnPack() *ConnectRequestT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ConnectRequestT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ConnectRequest struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsConnectRequest(buf []byte, offset flatbuffers.UOffsetT) *ConnectRequest {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &ConnectRequest{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsConnectRequest(buf []byte, offset flatbuffers.UOffsetT) *ConnectRequest {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ConnectRequest{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *ConnectRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ConnectRequest) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *ConnectRequest) Name() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *ConnectRequest) Arch() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *ConnectRequest) GitRevision() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *ConnectRequest) SyzRevision() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func ConnectRequestStart(builder *flatbuffers.Builder) {
+ builder.StartObject(4)
+}
+func ConnectRequestAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func ConnectRequestAddArch(builder *flatbuffers.Builder, arch flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(arch), 0)
+}
+func ConnectRequestAddGitRevision(builder *flatbuffers.Builder, gitRevision flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(gitRevision), 0)
+}
+func ConnectRequestAddSyzRevision(builder *flatbuffers.Builder, syzRevision flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(syzRevision), 0)
+}
+func ConnectRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type ConnectReplyT struct {
+ LeakFrames []string `json:"leak_frames"`
+ RaceFrames []string `json:"race_frames"`
+ Features Feature `json:"features"`
+ Files []string `json:"files"`
+ Globs []string `json:"globs"`
+}
+
+func (t *ConnectReplyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ leakFramesOffset := flatbuffers.UOffsetT(0)
+ if t.LeakFrames != nil {
+ leakFramesLength := len(t.LeakFrames)
+ leakFramesOffsets := make([]flatbuffers.UOffsetT, leakFramesLength)
+ for j := 0; j < leakFramesLength; j++ {
+ leakFramesOffsets[j] = builder.CreateString(t.LeakFrames[j])
+ }
+ ConnectReplyStartLeakFramesVector(builder, leakFramesLength)
+ for j := leakFramesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(leakFramesOffsets[j])
+ }
+ leakFramesOffset = builder.EndVector(leakFramesLength)
+ }
+ raceFramesOffset := flatbuffers.UOffsetT(0)
+ if t.RaceFrames != nil {
+ raceFramesLength := len(t.RaceFrames)
+ raceFramesOffsets := make([]flatbuffers.UOffsetT, raceFramesLength)
+ for j := 0; j < raceFramesLength; j++ {
+ raceFramesOffsets[j] = builder.CreateString(t.RaceFrames[j])
+ }
+ ConnectReplyStartRaceFramesVector(builder, raceFramesLength)
+ for j := raceFramesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(raceFramesOffsets[j])
+ }
+ raceFramesOffset = builder.EndVector(raceFramesLength)
+ }
+ filesOffset := flatbuffers.UOffsetT(0)
+ if t.Files != nil {
+ filesLength := len(t.Files)
+ filesOffsets := make([]flatbuffers.UOffsetT, filesLength)
+ for j := 0; j < filesLength; j++ {
+ filesOffsets[j] = builder.CreateString(t.Files[j])
+ }
+ ConnectReplyStartFilesVector(builder, filesLength)
+ for j := filesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(filesOffsets[j])
+ }
+ filesOffset = builder.EndVector(filesLength)
+ }
+ globsOffset := flatbuffers.UOffsetT(0)
+ if t.Globs != nil {
+ globsLength := len(t.Globs)
+ globsOffsets := make([]flatbuffers.UOffsetT, globsLength)
+ for j := 0; j < globsLength; j++ {
+ globsOffsets[j] = builder.CreateString(t.Globs[j])
+ }
+ ConnectReplyStartGlobsVector(builder, globsLength)
+ for j := globsLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(globsOffsets[j])
+ }
+ globsOffset = builder.EndVector(globsLength)
+ }
+ ConnectReplyStart(builder)
+ ConnectReplyAddLeakFrames(builder, leakFramesOffset)
+ ConnectReplyAddRaceFrames(builder, raceFramesOffset)
+ ConnectReplyAddFeatures(builder, t.Features)
+ ConnectReplyAddFiles(builder, filesOffset)
+ ConnectReplyAddGlobs(builder, globsOffset)
+ return ConnectReplyEnd(builder)
+}
+
+func (rcv *ConnectReply) UnPackTo(t *ConnectReplyT) {
+ leakFramesLength := rcv.LeakFramesLength()
+ t.LeakFrames = make([]string, leakFramesLength)
+ for j := 0; j < leakFramesLength; j++ {
+ t.LeakFrames[j] = string(rcv.LeakFrames(j))
+ }
+ raceFramesLength := rcv.RaceFramesLength()
+ t.RaceFrames = make([]string, raceFramesLength)
+ for j := 0; j < raceFramesLength; j++ {
+ t.RaceFrames[j] = string(rcv.RaceFrames(j))
+ }
+ t.Features = rcv.Features()
+ filesLength := rcv.FilesLength()
+ t.Files = make([]string, filesLength)
+ for j := 0; j < filesLength; j++ {
+ t.Files[j] = string(rcv.Files(j))
+ }
+ globsLength := rcv.GlobsLength()
+ t.Globs = make([]string, globsLength)
+ for j := 0; j < globsLength; j++ {
+ t.Globs[j] = string(rcv.Globs(j))
+ }
+}
+
+func (rcv *ConnectReply) UnPack() *ConnectReplyT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ConnectReplyT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ConnectReply struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsConnectReply(buf []byte, offset flatbuffers.UOffsetT) *ConnectReply {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &ConnectReply{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsConnectReply(buf []byte, offset flatbuffers.UOffsetT) *ConnectReply {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ConnectReply{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *ConnectReply) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ConnectReply) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *ConnectReply) LeakFrames(j int) []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+ }
+ return nil
+}
+
+func (rcv *ConnectReply) LeakFramesLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ConnectReply) RaceFrames(j int) []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+ }
+ return nil
+}
+
+func (rcv *ConnectReply) RaceFramesLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ConnectReply) Features() Feature {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return Feature(rcv._tab.GetUint64(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *ConnectReply) MutateFeatures(n Feature) bool {
+ return rcv._tab.MutateUint64Slot(8, uint64(n))
+}
+
+func (rcv *ConnectReply) Files(j int) []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+ }
+ return nil
+}
+
+func (rcv *ConnectReply) FilesLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ConnectReply) Globs(j int) []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+ }
+ return nil
+}
+
+func (rcv *ConnectReply) GlobsLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func ConnectReplyStart(builder *flatbuffers.Builder) {
+ builder.StartObject(5)
+}
+func ConnectReplyAddLeakFrames(builder *flatbuffers.Builder, leakFrames flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(leakFrames), 0)
+}
+func ConnectReplyStartLeakFramesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func ConnectReplyAddRaceFrames(builder *flatbuffers.Builder, raceFrames flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(raceFrames), 0)
+}
+func ConnectReplyStartRaceFramesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func ConnectReplyAddFeatures(builder *flatbuffers.Builder, features Feature) {
+ builder.PrependUint64Slot(2, uint64(features), 0)
+}
+func ConnectReplyAddFiles(builder *flatbuffers.Builder, files flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(files), 0)
+}
+func ConnectReplyStartFilesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func ConnectReplyAddGlobs(builder *flatbuffers.Builder, globs flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(globs), 0)
+}
+func ConnectReplyStartGlobsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func ConnectReplyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type InfoRequestT struct {
+ Error string `json:"error"`
+ Features Feature `json:"features"`
+ Globs []*GlobInfoT `json:"globs"`
+ Files []*FileInfoT `json:"files"`
+}
+
+func (t *InfoRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ errorOffset := builder.CreateString(t.Error)
+ globsOffset := flatbuffers.UOffsetT(0)
+ if t.Globs != nil {
+ globsLength := len(t.Globs)
+ globsOffsets := make([]flatbuffers.UOffsetT, globsLength)
+ for j := 0; j < globsLength; j++ {
+ globsOffsets[j] = t.Globs[j].Pack(builder)
+ }
+ InfoRequestStartGlobsVector(builder, globsLength)
+ for j := globsLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(globsOffsets[j])
+ }
+ globsOffset = builder.EndVector(globsLength)
+ }
+ filesOffset := flatbuffers.UOffsetT(0)
+ if t.Files != nil {
+ filesLength := len(t.Files)
+ filesOffsets := make([]flatbuffers.UOffsetT, filesLength)
+ for j := 0; j < filesLength; j++ {
+ filesOffsets[j] = t.Files[j].Pack(builder)
+ }
+ InfoRequestStartFilesVector(builder, filesLength)
+ for j := filesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(filesOffsets[j])
+ }
+ filesOffset = builder.EndVector(filesLength)
+ }
+ InfoRequestStart(builder)
+ InfoRequestAddError(builder, errorOffset)
+ InfoRequestAddFeatures(builder, t.Features)
+ InfoRequestAddGlobs(builder, globsOffset)
+ InfoRequestAddFiles(builder, filesOffset)
+ return InfoRequestEnd(builder)
+}
+
+func (rcv *InfoRequest) UnPackTo(t *InfoRequestT) {
+ t.Error = string(rcv.Error())
+ t.Features = rcv.Features()
+ globsLength := rcv.GlobsLength()
+ t.Globs = make([]*GlobInfoT, globsLength)
+ for j := 0; j < globsLength; j++ {
+ x := GlobInfo{}
+ rcv.Globs(&x, j)
+ t.Globs[j] = x.UnPack()
+ }
+ filesLength := rcv.FilesLength()
+ t.Files = make([]*FileInfoT, filesLength)
+ for j := 0; j < filesLength; j++ {
+ x := FileInfo{}
+ rcv.Files(&x, j)
+ t.Files[j] = x.UnPack()
+ }
+}
+
+func (rcv *InfoRequest) UnPack() *InfoRequestT {
+ if rcv == nil {
+ return nil
+ }
+ t := &InfoRequestT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type InfoRequest struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *InfoRequest {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &InfoRequest{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsInfoRequest(buf []byte, offset flatbuffers.UOffsetT) *InfoRequest {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &InfoRequest{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *InfoRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *InfoRequest) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *InfoRequest) Error() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *InfoRequest) Features() Feature {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return Feature(rcv._tab.GetUint64(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *InfoRequest) MutateFeatures(n Feature) bool {
+ return rcv._tab.MutateUint64Slot(6, uint64(n))
+}
+
+func (rcv *InfoRequest) Globs(obj *GlobInfo, j int) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ x := rcv._tab.Vector(o)
+ x += flatbuffers.UOffsetT(j) * 4
+ x = rcv._tab.Indirect(x)
+ obj.Init(rcv._tab.Bytes, x)
+ return true
+ }
+ return false
+}
+
+func (rcv *InfoRequest) GlobsLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *InfoRequest) Files(obj *FileInfo, j int) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ x := rcv._tab.Vector(o)
+ x += flatbuffers.UOffsetT(j) * 4
+ x = rcv._tab.Indirect(x)
+ obj.Init(rcv._tab.Bytes, x)
+ return true
+ }
+ return false
+}
+
+func (rcv *InfoRequest) FilesLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func InfoRequestStart(builder *flatbuffers.Builder) {
+ builder.StartObject(4)
+}
+func InfoRequestAddError(builder *flatbuffers.Builder, error flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(error), 0)
+}
+func InfoRequestAddFeatures(builder *flatbuffers.Builder, features Feature) {
+ builder.PrependUint64Slot(1, uint64(features), 0)
+}
+func InfoRequestAddGlobs(builder *flatbuffers.Builder, globs flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(globs), 0)
+}
+func InfoRequestStartGlobsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func InfoRequestAddFiles(builder *flatbuffers.Builder, files flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(files), 0)
+}
+func InfoRequestStartFilesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func InfoRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type InfoReplyT struct {
+ CoverFilter []uint32 `json:"cover_filter"`
+}
+
+func (t *InfoReplyT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ coverFilterOffset := flatbuffers.UOffsetT(0)
+ if t.CoverFilter != nil {
+ coverFilterLength := len(t.CoverFilter)
+ InfoReplyStartCoverFilterVector(builder, coverFilterLength)
+ for j := coverFilterLength - 1; j >= 0; j-- {
+ builder.PrependUint32(t.CoverFilter[j])
+ }
+ coverFilterOffset = builder.EndVector(coverFilterLength)
+ }
+ InfoReplyStart(builder)
+ InfoReplyAddCoverFilter(builder, coverFilterOffset)
+ return InfoReplyEnd(builder)
+}
+
+func (rcv *InfoReply) UnPackTo(t *InfoReplyT) {
+ coverFilterLength := rcv.CoverFilterLength()
+ t.CoverFilter = make([]uint32, coverFilterLength)
+ for j := 0; j < coverFilterLength; j++ {
+ t.CoverFilter[j] = rcv.CoverFilter(j)
+ }
+}
+
+func (rcv *InfoReply) UnPack() *InfoReplyT {
+ if rcv == nil {
+ return nil
+ }
+ t := &InfoReplyT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type InfoReply struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsInfoReply(buf []byte, offset flatbuffers.UOffsetT) *InfoReply {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &InfoReply{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsInfoReply(buf []byte, offset flatbuffers.UOffsetT) *InfoReply {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &InfoReply{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *InfoReply) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *InfoReply) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *InfoReply) CoverFilter(j int) uint32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4))
+ }
+ return 0
+}
+
+func (rcv *InfoReply) CoverFilterLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *InfoReply) MutateCoverFilter(j int, n uint32) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n)
+ }
+ return false
+}
+
+func InfoReplyStart(builder *flatbuffers.Builder) {
+ builder.StartObject(1)
+}
+func InfoReplyAddCoverFilter(builder *flatbuffers.Builder, coverFilter flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(coverFilter), 0)
+}
+func InfoReplyStartCoverFilterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func InfoReplyEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type FileInfoT struct {
+ Name string `json:"name"`
+ Exists bool `json:"exists"`
+ Error string `json:"error"`
+ Data []byte `json:"data"`
+}
+
+func (t *FileInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ nameOffset := builder.CreateString(t.Name)
+ errorOffset := builder.CreateString(t.Error)
+ dataOffset := flatbuffers.UOffsetT(0)
+ if t.Data != nil {
+ dataOffset = builder.CreateByteString(t.Data)
+ }
+ FileInfoStart(builder)
+ FileInfoAddName(builder, nameOffset)
+ FileInfoAddExists(builder, t.Exists)
+ FileInfoAddError(builder, errorOffset)
+ FileInfoAddData(builder, dataOffset)
+ return FileInfoEnd(builder)
+}
+
+func (rcv *FileInfo) UnPackTo(t *FileInfoT) {
+ t.Name = string(rcv.Name())
+ t.Exists = rcv.Exists()
+ t.Error = string(rcv.Error())
+ t.Data = rcv.DataBytes()
+}
+
+func (rcv *FileInfo) UnPack() *FileInfoT {
+ if rcv == nil {
+ return nil
+ }
+ t := &FileInfoT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type FileInfo struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsFileInfo(buf []byte, offset flatbuffers.UOffsetT) *FileInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &FileInfo{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsFileInfo(buf []byte, offset flatbuffers.UOffsetT) *FileInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &FileInfo{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *FileInfo) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *FileInfo) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *FileInfo) Name() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *FileInfo) Exists() bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.GetBool(o + rcv._tab.Pos)
+ }
+ return false
+}
+
+func (rcv *FileInfo) MutateExists(n bool) bool {
+ return rcv._tab.MutateBoolSlot(6, n)
+}
+
+func (rcv *FileInfo) Error() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *FileInfo) Data(j int) byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
+ }
+ return 0
+}
+
+func (rcv *FileInfo) DataLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *FileInfo) DataBytes() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *FileInfo) MutateData(j int, n byte) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
+ }
+ return false
+}
+
+func FileInfoStart(builder *flatbuffers.Builder) {
+ builder.StartObject(4)
+}
+func FileInfoAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func FileInfoAddExists(builder *flatbuffers.Builder, exists bool) {
+ builder.PrependBoolSlot(1, exists, false)
+}
+func FileInfoAddError(builder *flatbuffers.Builder, error flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(error), 0)
+}
+func FileInfoAddData(builder *flatbuffers.Builder, data flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(data), 0)
+}
+func FileInfoStartDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(1, numElems, 1)
+}
+func FileInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type GlobInfoT struct {
+ Name string `json:"name"`
+ Files []string `json:"files"`
+}
+
+func (t *GlobInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ nameOffset := builder.CreateString(t.Name)
+ filesOffset := flatbuffers.UOffsetT(0)
+ if t.Files != nil {
+ filesLength := len(t.Files)
+ filesOffsets := make([]flatbuffers.UOffsetT, filesLength)
+ for j := 0; j < filesLength; j++ {
+ filesOffsets[j] = builder.CreateString(t.Files[j])
+ }
+ GlobInfoStartFilesVector(builder, filesLength)
+ for j := filesLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(filesOffsets[j])
+ }
+ filesOffset = builder.EndVector(filesLength)
+ }
+ GlobInfoStart(builder)
+ GlobInfoAddName(builder, nameOffset)
+ GlobInfoAddFiles(builder, filesOffset)
+ return GlobInfoEnd(builder)
+}
+
+func (rcv *GlobInfo) UnPackTo(t *GlobInfoT) {
+ t.Name = string(rcv.Name())
+ filesLength := rcv.FilesLength()
+ t.Files = make([]string, filesLength)
+ for j := 0; j < filesLength; j++ {
+ t.Files[j] = string(rcv.Files(j))
+ }
+}
+
+func (rcv *GlobInfo) UnPack() *GlobInfoT {
+ if rcv == nil {
+ return nil
+ }
+ t := &GlobInfoT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type GlobInfo struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsGlobInfo(buf []byte, offset flatbuffers.UOffsetT) *GlobInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &GlobInfo{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsGlobInfo(buf []byte, offset flatbuffers.UOffsetT) *GlobInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &GlobInfo{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *GlobInfo) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *GlobInfo) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *GlobInfo) Name() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *GlobInfo) Files(j int) []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.ByteVector(a + flatbuffers.UOffsetT(j*4))
+ }
+ return nil
+}
+
+func (rcv *GlobInfo) FilesLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func GlobInfoStart(builder *flatbuffers.Builder) {
+ builder.StartObject(2)
+}
+func GlobInfoAddName(builder *flatbuffers.Builder, name flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(name), 0)
+}
+func GlobInfoAddFiles(builder *flatbuffers.Builder, files flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(files), 0)
+}
+func GlobInfoStartFilesVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func GlobInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type HostMessageT struct {
+ Msg *HostMessagesT `json:"msg"`
+}
+
+func (t *HostMessageT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ msgOffset := t.Msg.Pack(builder)
+
+ HostMessageStart(builder)
+ if t.Msg != nil {
+ HostMessageAddMsgType(builder, t.Msg.Type)
+ }
+ HostMessageAddMsg(builder, msgOffset)
+ return HostMessageEnd(builder)
+}
+
+func (rcv *HostMessage) UnPackTo(t *HostMessageT) {
+ msgTable := flatbuffers.Table{}
+ if rcv.Msg(&msgTable) {
+ t.Msg = rcv.MsgType().UnPack(msgTable)
+ }
+}
+
+func (rcv *HostMessage) UnPack() *HostMessageT {
+ if rcv == nil {
+ return nil
+ }
+ t := &HostMessageT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type HostMessage struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsHostMessage(buf []byte, offset flatbuffers.UOffsetT) *HostMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &HostMessage{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsHostMessage(buf []byte, offset flatbuffers.UOffsetT) *HostMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &HostMessage{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *HostMessage) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *HostMessage) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *HostMessage) MsgType() HostMessages {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return HostMessages(rcv._tab.GetByte(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *HostMessage) MutateMsgType(n HostMessages) bool {
+ return rcv._tab.MutateByteSlot(4, byte(n))
+}
+
+func (rcv *HostMessage) Msg(obj *flatbuffers.Table) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ rcv._tab.Union(obj, o)
+ return true
+ }
+ return false
+}
+
+func HostMessageStart(builder *flatbuffers.Builder) {
+ builder.StartObject(2)
+}
+func HostMessageAddMsgType(builder *flatbuffers.Builder, msgType HostMessages) {
+ builder.PrependByteSlot(0, byte(msgType), 0)
+}
+func HostMessageAddMsg(builder *flatbuffers.Builder, msg flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(msg), 0)
+}
+func HostMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type ExecutorMessageT struct {
+ Msg *ExecutorMessagesT `json:"msg"`
+}
+
+func (t *ExecutorMessageT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ msgOffset := t.Msg.Pack(builder)
+
+ ExecutorMessageStart(builder)
+ if t.Msg != nil {
+ ExecutorMessageAddMsgType(builder, t.Msg.Type)
+ }
+ ExecutorMessageAddMsg(builder, msgOffset)
+ return ExecutorMessageEnd(builder)
+}
+
+func (rcv *ExecutorMessage) UnPackTo(t *ExecutorMessageT) {
+ msgTable := flatbuffers.Table{}
+ if rcv.Msg(&msgTable) {
+ t.Msg = rcv.MsgType().UnPack(msgTable)
+ }
+}
+
+func (rcv *ExecutorMessage) UnPack() *ExecutorMessageT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ExecutorMessageT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ExecutorMessage struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsExecutorMessage(buf []byte, offset flatbuffers.UOffsetT) *ExecutorMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &ExecutorMessage{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsExecutorMessage(buf []byte, offset flatbuffers.UOffsetT) *ExecutorMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ExecutorMessage{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *ExecutorMessage) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ExecutorMessage) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *ExecutorMessage) MsgType() ExecutorMessages {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return ExecutorMessages(rcv._tab.GetByte(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *ExecutorMessage) MutateMsgType(n ExecutorMessages) bool {
+ return rcv._tab.MutateByteSlot(4, byte(n))
+}
+
+func (rcv *ExecutorMessage) Msg(obj *flatbuffers.Table) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ rcv._tab.Union(obj, o)
+ return true
+ }
+ return false
+}
+
+func ExecutorMessageStart(builder *flatbuffers.Builder) {
+ builder.StartObject(2)
+}
+func ExecutorMessageAddMsgType(builder *flatbuffers.Builder, msgType ExecutorMessages) {
+ builder.PrependByteSlot(0, byte(msgType), 0)
+}
+func ExecutorMessageAddMsg(builder *flatbuffers.Builder, msg flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(msg), 0)
+}
+func ExecutorMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type ExecRequestT struct {
+ Id int64 `json:"id"`
+ ProgData []byte `json:"prog_data"`
+ Flags RequestFlag `json:"flags"`
+ ExecEnv ExecEnv `json:"exec_env"`
+ ExecFlags ExecFlag `json:"exec_flags"`
+ SandboxArg int64 `json:"sandbox_arg"`
+ SignalFilter []uint32 `json:"signal_filter"`
+ SignalFilterCall int32 `json:"signal_filter_call"`
+ Repeat int32 `json:"repeat"`
+}
+
+func (t *ExecRequestT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ progDataOffset := flatbuffers.UOffsetT(0)
+ if t.ProgData != nil {
+ progDataOffset = builder.CreateByteString(t.ProgData)
+ }
+ signalFilterOffset := flatbuffers.UOffsetT(0)
+ if t.SignalFilter != nil {
+ signalFilterLength := len(t.SignalFilter)
+ ExecRequestStartSignalFilterVector(builder, signalFilterLength)
+ for j := signalFilterLength - 1; j >= 0; j-- {
+ builder.PrependUint32(t.SignalFilter[j])
+ }
+ signalFilterOffset = builder.EndVector(signalFilterLength)
+ }
+ ExecRequestStart(builder)
+ ExecRequestAddId(builder, t.Id)
+ ExecRequestAddProgData(builder, progDataOffset)
+ ExecRequestAddFlags(builder, t.Flags)
+ ExecRequestAddExecEnv(builder, t.ExecEnv)
+ ExecRequestAddExecFlags(builder, t.ExecFlags)
+ ExecRequestAddSandboxArg(builder, t.SandboxArg)
+ ExecRequestAddSignalFilter(builder, signalFilterOffset)
+ ExecRequestAddSignalFilterCall(builder, t.SignalFilterCall)
+ ExecRequestAddRepeat(builder, t.Repeat)
+ return ExecRequestEnd(builder)
+}
+
+func (rcv *ExecRequest) UnPackTo(t *ExecRequestT) {
+ t.Id = rcv.Id()
+ t.ProgData = rcv.ProgDataBytes()
+ t.Flags = rcv.Flags()
+ t.ExecEnv = rcv.ExecEnv()
+ t.ExecFlags = rcv.ExecFlags()
+ t.SandboxArg = rcv.SandboxArg()
+ signalFilterLength := rcv.SignalFilterLength()
+ t.SignalFilter = make([]uint32, signalFilterLength)
+ for j := 0; j < signalFilterLength; j++ {
+ t.SignalFilter[j] = rcv.SignalFilter(j)
+ }
+ t.SignalFilterCall = rcv.SignalFilterCall()
+ t.Repeat = rcv.Repeat()
+}
+
+func (rcv *ExecRequest) UnPack() *ExecRequestT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ExecRequestT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ExecRequest struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsExecRequest(buf []byte, offset flatbuffers.UOffsetT) *ExecRequest {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &ExecRequest{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsExecRequest(buf []byte, offset flatbuffers.UOffsetT) *ExecRequest {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ExecRequest{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *ExecRequest) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ExecRequest) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *ExecRequest) Id() int64 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.GetInt64(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateId(n int64) bool {
+ return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *ExecRequest) ProgData(j int) byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) ProgDataLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) ProgDataBytes() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *ExecRequest) MutateProgData(j int, n byte) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
+ }
+ return false
+}
+
+func (rcv *ExecRequest) Flags() RequestFlag {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return RequestFlag(rcv._tab.GetUint64(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateFlags(n RequestFlag) bool {
+ return rcv._tab.MutateUint64Slot(8, uint64(n))
+}
+
+func (rcv *ExecRequest) ExecEnv() ExecEnv {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return ExecEnv(rcv._tab.GetUint64(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateExecEnv(n ExecEnv) bool {
+ return rcv._tab.MutateUint64Slot(10, uint64(n))
+}
+
+func (rcv *ExecRequest) ExecFlags() ExecFlag {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ if o != 0 {
+ return ExecFlag(rcv._tab.GetUint64(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateExecFlags(n ExecFlag) bool {
+ return rcv._tab.MutateUint64Slot(12, uint64(n))
+}
+
+func (rcv *ExecRequest) SandboxArg() int64 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(14))
+ if o != 0 {
+ return rcv._tab.GetInt64(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateSandboxArg(n int64) bool {
+ return rcv._tab.MutateInt64Slot(14, n)
+}
+
+func (rcv *ExecRequest) SignalFilter(j int) uint32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4))
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) SignalFilterLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateSignalFilter(j int, n uint32) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(16))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n)
+ }
+ return false
+}
+
+func (rcv *ExecRequest) SignalFilterCall() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(18))
+ if o != 0 {
+ return rcv._tab.GetInt32(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateSignalFilterCall(n int32) bool {
+ return rcv._tab.MutateInt32Slot(18, n)
+}
+
+func (rcv *ExecRequest) Repeat() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(20))
+ if o != 0 {
+ return rcv._tab.GetInt32(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ExecRequest) MutateRepeat(n int32) bool {
+ return rcv._tab.MutateInt32Slot(20, n)
+}
+
+func ExecRequestStart(builder *flatbuffers.Builder) {
+ builder.StartObject(9)
+}
+func ExecRequestAddId(builder *flatbuffers.Builder, id int64) {
+ builder.PrependInt64Slot(0, id, 0)
+}
+func ExecRequestAddProgData(builder *flatbuffers.Builder, progData flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(progData), 0)
+}
+func ExecRequestStartProgDataVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(1, numElems, 1)
+}
+func ExecRequestAddFlags(builder *flatbuffers.Builder, flags RequestFlag) {
+ builder.PrependUint64Slot(2, uint64(flags), 0)
+}
+func ExecRequestAddExecEnv(builder *flatbuffers.Builder, execEnv ExecEnv) {
+ builder.PrependUint64Slot(3, uint64(execEnv), 0)
+}
+func ExecRequestAddExecFlags(builder *flatbuffers.Builder, execFlags ExecFlag) {
+ builder.PrependUint64Slot(4, uint64(execFlags), 0)
+}
+func ExecRequestAddSandboxArg(builder *flatbuffers.Builder, sandboxArg int64) {
+ builder.PrependInt64Slot(5, sandboxArg, 0)
+}
+func ExecRequestAddSignalFilter(builder *flatbuffers.Builder, signalFilter flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(6, flatbuffers.UOffsetT(signalFilter), 0)
+}
+func ExecRequestStartSignalFilterVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func ExecRequestAddSignalFilterCall(builder *flatbuffers.Builder, signalFilterCall int32) {
+ builder.PrependInt32Slot(7, signalFilterCall, 0)
+}
+func ExecRequestAddRepeat(builder *flatbuffers.Builder, repeat int32) {
+ builder.PrependInt32Slot(8, repeat, 0)
+}
+func ExecRequestEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type SignalUpdateT struct {
+ NewMax []uint32 `json:"new_max"`
+ DropMax []uint32 `json:"drop_max"`
+}
+
+func (t *SignalUpdateT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ newMaxOffset := flatbuffers.UOffsetT(0)
+ if t.NewMax != nil {
+ newMaxLength := len(t.NewMax)
+ SignalUpdateStartNewMaxVector(builder, newMaxLength)
+ for j := newMaxLength - 1; j >= 0; j-- {
+ builder.PrependUint32(t.NewMax[j])
+ }
+ newMaxOffset = builder.EndVector(newMaxLength)
+ }
+ dropMaxOffset := flatbuffers.UOffsetT(0)
+ if t.DropMax != nil {
+ dropMaxLength := len(t.DropMax)
+ SignalUpdateStartDropMaxVector(builder, dropMaxLength)
+ for j := dropMaxLength - 1; j >= 0; j-- {
+ builder.PrependUint32(t.DropMax[j])
+ }
+ dropMaxOffset = builder.EndVector(dropMaxLength)
+ }
+ SignalUpdateStart(builder)
+ SignalUpdateAddNewMax(builder, newMaxOffset)
+ SignalUpdateAddDropMax(builder, dropMaxOffset)
+ return SignalUpdateEnd(builder)
+}
+
+func (rcv *SignalUpdate) UnPackTo(t *SignalUpdateT) {
+ newMaxLength := rcv.NewMaxLength()
+ t.NewMax = make([]uint32, newMaxLength)
+ for j := 0; j < newMaxLength; j++ {
+ t.NewMax[j] = rcv.NewMax(j)
+ }
+ dropMaxLength := rcv.DropMaxLength()
+ t.DropMax = make([]uint32, dropMaxLength)
+ for j := 0; j < dropMaxLength; j++ {
+ t.DropMax[j] = rcv.DropMax(j)
+ }
+}
+
+func (rcv *SignalUpdate) UnPack() *SignalUpdateT {
+ if rcv == nil {
+ return nil
+ }
+ t := &SignalUpdateT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type SignalUpdate struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsSignalUpdate(buf []byte, offset flatbuffers.UOffsetT) *SignalUpdate {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &SignalUpdate{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsSignalUpdate(buf []byte, offset flatbuffers.UOffsetT) *SignalUpdate {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &SignalUpdate{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *SignalUpdate) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *SignalUpdate) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *SignalUpdate) NewMax(j int) uint32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4))
+ }
+ return 0
+}
+
+func (rcv *SignalUpdate) NewMaxLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *SignalUpdate) MutateNewMax(j int, n uint32) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n)
+ }
+ return false
+}
+
+func (rcv *SignalUpdate) DropMax(j int) uint32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4))
+ }
+ return 0
+}
+
+func (rcv *SignalUpdate) DropMaxLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *SignalUpdate) MutateDropMax(j int, n uint32) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n)
+ }
+ return false
+}
+
+func SignalUpdateStart(builder *flatbuffers.Builder) {
+ builder.StartObject(2)
+}
+func SignalUpdateAddNewMax(builder *flatbuffers.Builder, newMax flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(newMax), 0)
+}
+func SignalUpdateStartNewMaxVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func SignalUpdateAddDropMax(builder *flatbuffers.Builder, dropMax flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(dropMax), 0)
+}
+func SignalUpdateStartDropMaxVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func SignalUpdateEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type ExecutingMessageT struct {
+ Id int64 `json:"id"`
+ ProcId int32 `json:"proc_id"`
+ Try int32 `json:"try"`
+}
+
+func (t *ExecutingMessageT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ ExecutingMessageStart(builder)
+ ExecutingMessageAddId(builder, t.Id)
+ ExecutingMessageAddProcId(builder, t.ProcId)
+ ExecutingMessageAddTry(builder, t.Try)
+ return ExecutingMessageEnd(builder)
+}
+
+func (rcv *ExecutingMessage) UnPackTo(t *ExecutingMessageT) {
+ t.Id = rcv.Id()
+ t.ProcId = rcv.ProcId()
+ t.Try = rcv.Try()
+}
+
+func (rcv *ExecutingMessage) UnPack() *ExecutingMessageT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ExecutingMessageT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ExecutingMessage struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsExecutingMessage(buf []byte, offset flatbuffers.UOffsetT) *ExecutingMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &ExecutingMessage{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsExecutingMessage(buf []byte, offset flatbuffers.UOffsetT) *ExecutingMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ExecutingMessage{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *ExecutingMessage) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ExecutingMessage) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *ExecutingMessage) Id() int64 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.GetInt64(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ExecutingMessage) MutateId(n int64) bool {
+ return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *ExecutingMessage) ProcId() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.GetInt32(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ExecutingMessage) MutateProcId(n int32) bool {
+ return rcv._tab.MutateInt32Slot(6, n)
+}
+
+func (rcv *ExecutingMessage) Try() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return rcv._tab.GetInt32(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ExecutingMessage) MutateTry(n int32) bool {
+ return rcv._tab.MutateInt32Slot(8, n)
+}
+
+func ExecutingMessageStart(builder *flatbuffers.Builder) {
+ builder.StartObject(3)
+}
+func ExecutingMessageAddId(builder *flatbuffers.Builder, id int64) {
+ builder.PrependInt64Slot(0, id, 0)
+}
+func ExecutingMessageAddProcId(builder *flatbuffers.Builder, procId int32) {
+ builder.PrependInt32Slot(1, procId, 0)
+}
+func ExecutingMessageAddTry(builder *flatbuffers.Builder, try int32) {
+ builder.PrependInt32Slot(2, try, 0)
+}
+func ExecutingMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type StatsMessageT struct {
+ NoexecCount int64 `json:"noexec_count"`
+ NoexecDuration int64 `json:"noexec_duration"`
+}
+
+func (t *StatsMessageT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ StatsMessageStart(builder)
+ StatsMessageAddNoexecCount(builder, t.NoexecCount)
+ StatsMessageAddNoexecDuration(builder, t.NoexecDuration)
+ return StatsMessageEnd(builder)
+}
+
+func (rcv *StatsMessage) UnPackTo(t *StatsMessageT) {
+ t.NoexecCount = rcv.NoexecCount()
+ t.NoexecDuration = rcv.NoexecDuration()
+}
+
+func (rcv *StatsMessage) UnPack() *StatsMessageT {
+ if rcv == nil {
+ return nil
+ }
+ t := &StatsMessageT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type StatsMessage struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsStatsMessage(buf []byte, offset flatbuffers.UOffsetT) *StatsMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &StatsMessage{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsStatsMessage(buf []byte, offset flatbuffers.UOffsetT) *StatsMessage {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &StatsMessage{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *StatsMessage) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *StatsMessage) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *StatsMessage) NoexecCount() int64 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.GetInt64(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *StatsMessage) MutateNoexecCount(n int64) bool {
+ return rcv._tab.MutateInt64Slot(4, n)
+}
+
+func (rcv *StatsMessage) NoexecDuration() int64 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.GetInt64(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *StatsMessage) MutateNoexecDuration(n int64) bool {
+ return rcv._tab.MutateInt64Slot(6, n)
+}
+
+func StatsMessageStart(builder *flatbuffers.Builder) {
+ builder.StartObject(2)
+}
+func StatsMessageAddNoexecCount(builder *flatbuffers.Builder, noexecCount int64) {
+ builder.PrependInt64Slot(0, noexecCount, 0)
+}
+func StatsMessageAddNoexecDuration(builder *flatbuffers.Builder, noexecDuration int64) {
+ builder.PrependInt64Slot(1, noexecDuration, 0)
+}
+func StatsMessageEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type CallInfoT struct {
+ Flags CallFlag `json:"flags"`
+ Error int32 `json:"error"`
+ Signal []uint32 `json:"signal"`
+ Cover []uint32 `json:"cover"`
+ Comps []*ComparisonT `json:"comps"`
+}
+
+func (t *CallInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ signalOffset := flatbuffers.UOffsetT(0)
+ if t.Signal != nil {
+ signalLength := len(t.Signal)
+ CallInfoStartSignalVector(builder, signalLength)
+ for j := signalLength - 1; j >= 0; j-- {
+ builder.PrependUint32(t.Signal[j])
+ }
+ signalOffset = builder.EndVector(signalLength)
+ }
+ coverOffset := flatbuffers.UOffsetT(0)
+ if t.Cover != nil {
+ coverLength := len(t.Cover)
+ CallInfoStartCoverVector(builder, coverLength)
+ for j := coverLength - 1; j >= 0; j-- {
+ builder.PrependUint32(t.Cover[j])
+ }
+ coverOffset = builder.EndVector(coverLength)
+ }
+ compsOffset := flatbuffers.UOffsetT(0)
+ if t.Comps != nil {
+ compsLength := len(t.Comps)
+ CallInfoStartCompsVector(builder, compsLength)
+ for j := compsLength - 1; j >= 0; j-- {
+ t.Comps[j].Pack(builder)
+ }
+ compsOffset = builder.EndVector(compsLength)
+ }
+ CallInfoStart(builder)
+ CallInfoAddFlags(builder, t.Flags)
+ CallInfoAddError(builder, t.Error)
+ CallInfoAddSignal(builder, signalOffset)
+ CallInfoAddCover(builder, coverOffset)
+ CallInfoAddComps(builder, compsOffset)
+ return CallInfoEnd(builder)
+}
+
+func (rcv *CallInfo) UnPackTo(t *CallInfoT) {
+ t.Flags = rcv.Flags()
+ t.Error = rcv.Error()
+ signalLength := rcv.SignalLength()
+ t.Signal = make([]uint32, signalLength)
+ for j := 0; j < signalLength; j++ {
+ t.Signal[j] = rcv.Signal(j)
+ }
+ coverLength := rcv.CoverLength()
+ t.Cover = make([]uint32, coverLength)
+ for j := 0; j < coverLength; j++ {
+ t.Cover[j] = rcv.Cover(j)
+ }
+ compsLength := rcv.CompsLength()
+ t.Comps = make([]*ComparisonT, compsLength)
+ for j := 0; j < compsLength; j++ {
+ x := Comparison{}
+ rcv.Comps(&x, j)
+ t.Comps[j] = x.UnPack()
+ }
+}
+
+func (rcv *CallInfo) UnPack() *CallInfoT {
+ if rcv == nil {
+ return nil
+ }
+ t := &CallInfoT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type CallInfo struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsCallInfo(buf []byte, offset flatbuffers.UOffsetT) *CallInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &CallInfo{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsCallInfo(buf []byte, offset flatbuffers.UOffsetT) *CallInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &CallInfo{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *CallInfo) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *CallInfo) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *CallInfo) Flags() CallFlag {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return CallFlag(rcv._tab.GetByte(o + rcv._tab.Pos))
+ }
+ return 0
+}
+
+func (rcv *CallInfo) MutateFlags(n CallFlag) bool {
+ return rcv._tab.MutateByteSlot(4, byte(n))
+}
+
+func (rcv *CallInfo) Error() int32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.GetInt32(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *CallInfo) MutateError(n int32) bool {
+ return rcv._tab.MutateInt32Slot(6, n)
+}
+
+func (rcv *CallInfo) Signal(j int) uint32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4))
+ }
+ return 0
+}
+
+func (rcv *CallInfo) SignalLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *CallInfo) MutateSignal(j int, n uint32) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n)
+ }
+ return false
+}
+
+func (rcv *CallInfo) Cover(j int) uint32 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetUint32(a + flatbuffers.UOffsetT(j*4))
+ }
+ return 0
+}
+
+func (rcv *CallInfo) CoverLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *CallInfo) MutateCover(j int, n uint32) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateUint32(a+flatbuffers.UOffsetT(j*4), n)
+ }
+ return false
+}
+
+func (rcv *CallInfo) Comps(obj *Comparison, j int) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ if o != 0 {
+ x := rcv._tab.Vector(o)
+ x += flatbuffers.UOffsetT(j) * 16
+ obj.Init(rcv._tab.Bytes, x)
+ return true
+ }
+ return false
+}
+
+func (rcv *CallInfo) CompsLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(12))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func CallInfoStart(builder *flatbuffers.Builder) {
+ builder.StartObject(5)
+}
+func CallInfoAddFlags(builder *flatbuffers.Builder, flags CallFlag) {
+ builder.PrependByteSlot(0, byte(flags), 0)
+}
+func CallInfoAddError(builder *flatbuffers.Builder, error int32) {
+ builder.PrependInt32Slot(1, error, 0)
+}
+func CallInfoAddSignal(builder *flatbuffers.Builder, signal flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(signal), 0)
+}
+func CallInfoStartSignalVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func CallInfoAddCover(builder *flatbuffers.Builder, cover flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(cover), 0)
+}
+func CallInfoStartCoverVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func CallInfoAddComps(builder *flatbuffers.Builder, comps flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(4, flatbuffers.UOffsetT(comps), 0)
+}
+func CallInfoStartCompsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(16, numElems, 8)
+}
+func CallInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type ComparisonT struct {
+ Op1 uint64 `json:"op1"`
+ Op2 uint64 `json:"op2"`
+}
+
+func (t *ComparisonT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ return CreateComparison(builder, t.Op1, t.Op2)
+}
+func (rcv *Comparison) UnPackTo(t *ComparisonT) {
+ t.Op1 = rcv.Op1()
+ t.Op2 = rcv.Op2()
+}
+
+func (rcv *Comparison) UnPack() *ComparisonT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ComparisonT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type Comparison struct {
+ _tab flatbuffers.Struct
+}
+
+func (rcv *Comparison) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *Comparison) Table() flatbuffers.Table {
+ return rcv._tab.Table
+}
+
+func (rcv *Comparison) Op1() uint64 {
+ return rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(0))
+}
+func (rcv *Comparison) MutateOp1(n uint64) bool {
+ return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(0), n)
+}
+
+func (rcv *Comparison) Op2() uint64 {
+ return rcv._tab.GetUint64(rcv._tab.Pos + flatbuffers.UOffsetT(8))
+}
+func (rcv *Comparison) MutateOp2(n uint64) bool {
+ return rcv._tab.MutateUint64(rcv._tab.Pos+flatbuffers.UOffsetT(8), n)
+}
+
+func CreateComparison(builder *flatbuffers.Builder, op1 uint64, op2 uint64) flatbuffers.UOffsetT {
+ builder.Prep(8, 16)
+ builder.PrependUint64(op2)
+ builder.PrependUint64(op1)
+ return builder.Offset()
+}
+
+type ProgInfoT struct {
+ Calls []*CallInfoT `json:"calls"`
+ Extra *CallInfoT `json:"extra"`
+ Elapsed uint64 `json:"elapsed"`
+ Freshness uint64 `json:"freshness"`
+}
+
+func (t *ProgInfoT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ callsOffset := flatbuffers.UOffsetT(0)
+ if t.Calls != nil {
+ callsLength := len(t.Calls)
+ callsOffsets := make([]flatbuffers.UOffsetT, callsLength)
+ for j := 0; j < callsLength; j++ {
+ callsOffsets[j] = t.Calls[j].Pack(builder)
+ }
+ ProgInfoStartCallsVector(builder, callsLength)
+ for j := callsLength - 1; j >= 0; j-- {
+ builder.PrependUOffsetT(callsOffsets[j])
+ }
+ callsOffset = builder.EndVector(callsLength)
+ }
+ extraOffset := t.Extra.Pack(builder)
+ ProgInfoStart(builder)
+ ProgInfoAddCalls(builder, callsOffset)
+ ProgInfoAddExtra(builder, extraOffset)
+ ProgInfoAddElapsed(builder, t.Elapsed)
+ ProgInfoAddFreshness(builder, t.Freshness)
+ return ProgInfoEnd(builder)
+}
+
+func (rcv *ProgInfo) UnPackTo(t *ProgInfoT) {
+ callsLength := rcv.CallsLength()
+ t.Calls = make([]*CallInfoT, callsLength)
+ for j := 0; j < callsLength; j++ {
+ x := CallInfo{}
+ rcv.Calls(&x, j)
+ t.Calls[j] = x.UnPack()
+ }
+ t.Extra = rcv.Extra(nil).UnPack()
+ t.Elapsed = rcv.Elapsed()
+ t.Freshness = rcv.Freshness()
+}
+
+func (rcv *ProgInfo) UnPack() *ProgInfoT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ProgInfoT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ProgInfo struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsProgInfo(buf []byte, offset flatbuffers.UOffsetT) *ProgInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &ProgInfo{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsProgInfo(buf []byte, offset flatbuffers.UOffsetT) *ProgInfo {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ProgInfo{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *ProgInfo) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ProgInfo) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *ProgInfo) Calls(obj *CallInfo, j int) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ x := rcv._tab.Vector(o)
+ x += flatbuffers.UOffsetT(j) * 4
+ x = rcv._tab.Indirect(x)
+ obj.Init(rcv._tab.Bytes, x)
+ return true
+ }
+ return false
+}
+
+func (rcv *ProgInfo) CallsLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ProgInfo) Extra(obj *CallInfo) *CallInfo {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ x := rcv._tab.Indirect(o + rcv._tab.Pos)
+ if obj == nil {
+ obj = new(CallInfo)
+ }
+ obj.Init(rcv._tab.Bytes, x)
+ return obj
+ }
+ return nil
+}
+
+func (rcv *ProgInfo) Elapsed() uint64 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return rcv._tab.GetUint64(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ProgInfo) MutateElapsed(n uint64) bool {
+ return rcv._tab.MutateUint64Slot(8, n)
+}
+
+func (rcv *ProgInfo) Freshness() uint64 {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ return rcv._tab.GetUint64(o + rcv._tab.Pos)
+ }
+ return 0
+}
+
+func (rcv *ProgInfo) MutateFreshness(n uint64) bool {
+ return rcv._tab.MutateUint64Slot(10, n)
+}
+
+func ProgInfoStart(builder *flatbuffers.Builder) {
+ builder.StartObject(4)
+}
+func ProgInfoAddCalls(builder *flatbuffers.Builder, calls flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(calls), 0)
+}
+func ProgInfoStartCallsVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(4, numElems, 4)
+}
+func ProgInfoAddExtra(builder *flatbuffers.Builder, extra flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(extra), 0)
+}
+func ProgInfoAddElapsed(builder *flatbuffers.Builder, elapsed uint64) {
+ builder.PrependUint64Slot(2, elapsed, 0)
+}
+func ProgInfoAddFreshness(builder *flatbuffers.Builder, freshness uint64) {
+ builder.PrependUint64Slot(3, freshness, 0)
+}
+func ProgInfoEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
+
+type ExecResultT struct {
+ Executing *ExecutingMessageT `json:"executing"`
+ Output []byte `json:"output"`
+ Error string `json:"error"`
+ Info *ProgInfoT `json:"info"`
+}
+
+func (t *ExecResultT) Pack(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ if t == nil {
+ return 0
+ }
+ executingOffset := t.Executing.Pack(builder)
+ outputOffset := flatbuffers.UOffsetT(0)
+ if t.Output != nil {
+ outputOffset = builder.CreateByteString(t.Output)
+ }
+ errorOffset := builder.CreateString(t.Error)
+ infoOffset := t.Info.Pack(builder)
+ ExecResultStart(builder)
+ ExecResultAddExecuting(builder, executingOffset)
+ ExecResultAddOutput(builder, outputOffset)
+ ExecResultAddError(builder, errorOffset)
+ ExecResultAddInfo(builder, infoOffset)
+ return ExecResultEnd(builder)
+}
+
+func (rcv *ExecResult) UnPackTo(t *ExecResultT) {
+ t.Executing = rcv.Executing(nil).UnPack()
+ t.Output = rcv.OutputBytes()
+ t.Error = string(rcv.Error())
+ t.Info = rcv.Info(nil).UnPack()
+}
+
+func (rcv *ExecResult) UnPack() *ExecResultT {
+ if rcv == nil {
+ return nil
+ }
+ t := &ExecResultT{}
+ rcv.UnPackTo(t)
+ return t
+}
+
+type ExecResult struct {
+ _tab flatbuffers.Table
+}
+
+func GetRootAsExecResult(buf []byte, offset flatbuffers.UOffsetT) *ExecResult {
+ n := flatbuffers.GetUOffsetT(buf[offset:])
+ x := &ExecResult{}
+ x.Init(buf, n+offset)
+ return x
+}
+
+func GetSizePrefixedRootAsExecResult(buf []byte, offset flatbuffers.UOffsetT) *ExecResult {
+ n := flatbuffers.GetUOffsetT(buf[offset+flatbuffers.SizeUint32:])
+ x := &ExecResult{}
+ x.Init(buf, n+offset+flatbuffers.SizeUint32)
+ return x
+}
+
+func (rcv *ExecResult) Init(buf []byte, i flatbuffers.UOffsetT) {
+ rcv._tab.Bytes = buf
+ rcv._tab.Pos = i
+}
+
+func (rcv *ExecResult) Table() flatbuffers.Table {
+ return rcv._tab
+}
+
+func (rcv *ExecResult) Executing(obj *ExecutingMessage) *ExecutingMessage {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(4))
+ if o != 0 {
+ x := rcv._tab.Indirect(o + rcv._tab.Pos)
+ if obj == nil {
+ obj = new(ExecutingMessage)
+ }
+ obj.Init(rcv._tab.Bytes, x)
+ return obj
+ }
+ return nil
+}
+
+func (rcv *ExecResult) Output(j int) byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.GetByte(a + flatbuffers.UOffsetT(j*1))
+ }
+ return 0
+}
+
+func (rcv *ExecResult) OutputLength() int {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.VectorLen(o)
+ }
+ return 0
+}
+
+func (rcv *ExecResult) OutputBytes() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *ExecResult) MutateOutput(j int, n byte) bool {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(6))
+ if o != 0 {
+ a := rcv._tab.Vector(o)
+ return rcv._tab.MutateByte(a+flatbuffers.UOffsetT(j*1), n)
+ }
+ return false
+}
+
+func (rcv *ExecResult) Error() []byte {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(8))
+ if o != 0 {
+ return rcv._tab.ByteVector(o + rcv._tab.Pos)
+ }
+ return nil
+}
+
+func (rcv *ExecResult) Info(obj *ProgInfo) *ProgInfo {
+ o := flatbuffers.UOffsetT(rcv._tab.Offset(10))
+ if o != 0 {
+ x := rcv._tab.Indirect(o + rcv._tab.Pos)
+ if obj == nil {
+ obj = new(ProgInfo)
+ }
+ obj.Init(rcv._tab.Bytes, x)
+ return obj
+ }
+ return nil
+}
+
+func ExecResultStart(builder *flatbuffers.Builder) {
+ builder.StartObject(4)
+}
+func ExecResultAddExecuting(builder *flatbuffers.Builder, executing flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(0, flatbuffers.UOffsetT(executing), 0)
+}
+func ExecResultAddOutput(builder *flatbuffers.Builder, output flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(1, flatbuffers.UOffsetT(output), 0)
+}
+func ExecResultStartOutputVector(builder *flatbuffers.Builder, numElems int) flatbuffers.UOffsetT {
+ return builder.StartVector(1, numElems, 1)
+}
+func ExecResultAddError(builder *flatbuffers.Builder, error flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(2, flatbuffers.UOffsetT(error), 0)
+}
+func ExecResultAddInfo(builder *flatbuffers.Builder, info flatbuffers.UOffsetT) {
+ builder.PrependUOffsetTSlot(3, flatbuffers.UOffsetT(info), 0)
+}
+func ExecResultEnd(builder *flatbuffers.Builder) flatbuffers.UOffsetT {
+ return builder.EndObject()
+}
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<size_t>(e);
+ return EnumNamesHostMessages()[index];
+}
+
+template<typename T> struct HostMessagesTraits {
+ static const HostMessages enum_value = HostMessages::NONE;
+};
+
+template<> struct HostMessagesTraits<rpc::ExecRequest> {
+ static const HostMessages enum_value = HostMessages::ExecRequest;
+};
+
+template<> struct HostMessagesTraits<rpc::SignalUpdate> {
+ static const HostMessages enum_value = HostMessages::SignalUpdate;
+};
+
+template<typename T> struct HostMessagesUnionTraits {
+ static const HostMessages enum_value = HostMessages::NONE;
+};
+
+template<> struct HostMessagesUnionTraits<rpc::ExecRequestT> {
+ static const HostMessages enum_value = HostMessages::ExecRequest;
+};
+
+template<> struct HostMessagesUnionTraits<rpc::SignalUpdateT> {
+ 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 <typename T>
+ void Set(T&& val) {
+ typedef typename std::remove_reference<T>::type RT;
+ Reset();
+ type = HostMessagesUnionTraits<RT>::enum_value;
+ if (type != HostMessages::NONE) {
+ value = new RT(std::forward<T>(val));
+ }
+ }
+
+ static void *UnPack(const void *obj, HostMessages type, const flatbuffers::resolver_function_t *resolver);
+ flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
+
+ rpc::ExecRequestT *AsExecRequest() {
+ return type == HostMessages::ExecRequest ?
+ reinterpret_cast<rpc::ExecRequestT *>(value) : nullptr;
+ }
+ const rpc::ExecRequestT *AsExecRequest() const {
+ return type == HostMessages::ExecRequest ?
+ reinterpret_cast<const rpc::ExecRequestT *>(value) : nullptr;
+ }
+ rpc::SignalUpdateT *AsSignalUpdate() {
+ return type == HostMessages::SignalUpdate ?
+ reinterpret_cast<rpc::SignalUpdateT *>(value) : nullptr;
+ }
+ const rpc::SignalUpdateT *AsSignalUpdate() const {
+ return type == HostMessages::SignalUpdate ?
+ reinterpret_cast<const rpc::SignalUpdateT *>(value) : nullptr;
+ }
+};
+
+bool VerifyHostMessages(flatbuffers::Verifier &verifier, const void *obj, HostMessages type);
+bool VerifyHostMessagesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<HostMessages> *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<size_t>(e);
+ return EnumNamesExecutorMessages()[index];
+}
+
+template<typename T> struct ExecutorMessagesTraits {
+ static const ExecutorMessages enum_value = ExecutorMessages::NONE;
+};
+
+template<> struct ExecutorMessagesTraits<rpc::ExecResult> {
+ static const ExecutorMessages enum_value = ExecutorMessages::ExecResult;
+};
+
+template<> struct ExecutorMessagesTraits<rpc::ExecutingMessage> {
+ static const ExecutorMessages enum_value = ExecutorMessages::Executing;
+};
+
+template<> struct ExecutorMessagesTraits<rpc::StatsMessage> {
+ static const ExecutorMessages enum_value = ExecutorMessages::Stats;
+};
+
+template<typename T> struct ExecutorMessagesUnionTraits {
+ static const ExecutorMessages enum_value = ExecutorMessages::NONE;
+};
+
+template<> struct ExecutorMessagesUnionTraits<rpc::ExecResultT> {
+ static const ExecutorMessages enum_value = ExecutorMessages::ExecResult;
+};
+
+template<> struct ExecutorMessagesUnionTraits<rpc::ExecutingMessageT> {
+ static const ExecutorMessages enum_value = ExecutorMessages::Executing;
+};
+
+template<> struct ExecutorMessagesUnionTraits<rpc::StatsMessageT> {
+ 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 <typename T>
+ void Set(T&& val) {
+ typedef typename std::remove_reference<T>::type RT;
+ Reset();
+ type = ExecutorMessagesUnionTraits<RT>::enum_value;
+ if (type != ExecutorMessages::NONE) {
+ value = new RT(std::forward<T>(val));
+ }
+ }
+
+ static void *UnPack(const void *obj, ExecutorMessages type, const flatbuffers::resolver_function_t *resolver);
+ flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
+
+ rpc::ExecResultT *AsExecResult() {
+ return type == ExecutorMessages::ExecResult ?
+ reinterpret_cast<rpc::ExecResultT *>(value) : nullptr;
+ }
+ const rpc::ExecResultT *AsExecResult() const {
+ return type == ExecutorMessages::ExecResult ?
+ reinterpret_cast<const rpc::ExecResultT *>(value) : nullptr;
+ }
+ rpc::ExecutingMessageT *AsExecuting() {
+ return type == ExecutorMessages::Executing ?
+ reinterpret_cast<rpc::ExecutingMessageT *>(value) : nullptr;
+ }
+ const rpc::ExecutingMessageT *AsExecuting() const {
+ return type == ExecutorMessages::Executing ?
+ reinterpret_cast<const rpc::ExecutingMessageT *>(value) : nullptr;
+ }
+ rpc::StatsMessageT *AsStats() {
+ return type == ExecutorMessages::Stats ?
+ reinterpret_cast<rpc::StatsMessageT *>(value) : nullptr;
+ }
+ const rpc::StatsMessageT *AsStats() const {
+ return type == ExecutorMessages::Stats ?
+ reinterpret_cast<const rpc::StatsMessageT *>(value) : nullptr;
+ }
+};
+
+bool VerifyExecutorMessages(flatbuffers::Verifier &verifier, const void *obj, ExecutorMessages type);
+bool VerifyExecutorMessagesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<ExecutorMessages> *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<size_t>(e) - static_cast<size_t>(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<size_t>(e) - static_cast<size_t>(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<const flatbuffers::String *>(VT_NAME);
+ }
+ const flatbuffers::String *arch() const {
+ return GetPointer<const flatbuffers::String *>(VT_ARCH);
+ }
+ const flatbuffers::String *git_revision() const {
+ return GetPointer<const flatbuffers::String *>(VT_GIT_REVISION);
+ }
+ const flatbuffers::String *syz_revision() const {
+ return GetPointer<const flatbuffers::String *>(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<ConnectRequest> 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<flatbuffers::String> name) {
+ fbb_.AddOffset(ConnectRequest::VT_NAME, name);
+ }
+ void add_arch(flatbuffers::Offset<flatbuffers::String> arch) {
+ fbb_.AddOffset(ConnectRequest::VT_ARCH, arch);
+ }
+ void add_git_revision(flatbuffers::Offset<flatbuffers::String> git_revision) {
+ fbb_.AddOffset(ConnectRequest::VT_GIT_REVISION, git_revision);
+ }
+ void add_syz_revision(flatbuffers::Offset<flatbuffers::String> syz_revision) {
+ fbb_.AddOffset(ConnectRequest::VT_SYZ_REVISION, syz_revision);
+ }
+ explicit ConnectRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<ConnectRequest> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<ConnectRequest>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<ConnectRequest> CreateConnectRequest(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::String> name = 0,
+ flatbuffers::Offset<flatbuffers::String> arch = 0,
+ flatbuffers::Offset<flatbuffers::String> git_revision = 0,
+ flatbuffers::Offset<flatbuffers::String> 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<ConnectRequest> 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<ConnectRequest> CreateConnectRequest(flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct ConnectReplyT : public flatbuffers::NativeTable {
+ typedef ConnectReply TableType;
+ std::vector<std::string> leak_frames{};
+ std::vector<std::string> race_frames{};
+ rpc::Feature features = static_cast<rpc::Feature>(0);
+ std::vector<std::string> files{};
+ std::vector<std::string> 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<flatbuffers::Offset<flatbuffers::String>> *leak_frames() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_LEAK_FRAMES);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *race_frames() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_RACE_FRAMES);
+ }
+ rpc::Feature features() const {
+ return static_cast<rpc::Feature>(GetField<uint64_t>(VT_FEATURES, 0));
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *files() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_FILES);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *globs() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(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<uint64_t>(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<ConnectReply> 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<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> leak_frames) {
+ fbb_.AddOffset(ConnectReply::VT_LEAK_FRAMES, leak_frames);
+ }
+ void add_race_frames(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> race_frames) {
+ fbb_.AddOffset(ConnectReply::VT_RACE_FRAMES, race_frames);
+ }
+ void add_features(rpc::Feature features) {
+ fbb_.AddElement<uint64_t>(ConnectReply::VT_FEATURES, static_cast<uint64_t>(features), 0);
+ }
+ void add_files(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> files) {
+ fbb_.AddOffset(ConnectReply::VT_FILES, files);
+ }
+ void add_globs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> globs) {
+ fbb_.AddOffset(ConnectReply::VT_GLOBS, globs);
+ }
+ explicit ConnectReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<ConnectReply> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<ConnectReply>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<ConnectReply> CreateConnectReply(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> leak_frames = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> race_frames = 0,
+ rpc::Feature features = static_cast<rpc::Feature>(0),
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> files = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> 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<ConnectReply> CreateConnectReplyDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<flatbuffers::Offset<flatbuffers::String>> *leak_frames = nullptr,
+ const std::vector<flatbuffers::Offset<flatbuffers::String>> *race_frames = nullptr,
+ rpc::Feature features = static_cast<rpc::Feature>(0),
+ const std::vector<flatbuffers::Offset<flatbuffers::String>> *files = nullptr,
+ const std::vector<flatbuffers::Offset<flatbuffers::String>> *globs = nullptr) {
+ auto leak_frames__ = leak_frames ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*leak_frames) : 0;
+ auto race_frames__ = race_frames ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*race_frames) : 0;
+ auto files__ = files ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*files) : 0;
+ auto globs__ = globs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*globs) : 0;
+ return rpc::CreateConnectReply(
+ _fbb,
+ leak_frames__,
+ race_frames__,
+ features,
+ files__,
+ globs__);
+}
+
+flatbuffers::Offset<ConnectReply> 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<rpc::Feature>(0);
+ std::vector<std::unique_ptr<rpc::GlobInfoT>> globs{};
+ std::vector<std::unique_ptr<rpc::FileInfoT>> 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<const flatbuffers::String *>(VT_ERROR);
+ }
+ rpc::Feature features() const {
+ return static_cast<rpc::Feature>(GetField<uint64_t>(VT_FEATURES, 0));
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<rpc::GlobInfo>> *globs() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<rpc::GlobInfo>> *>(VT_GLOBS);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<rpc::FileInfo>> *files() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<rpc::FileInfo>> *>(VT_FILES);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_ERROR) &&
+ verifier.VerifyString(error()) &&
+ VerifyField<uint64_t>(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<InfoRequest> 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<flatbuffers::String> error) {
+ fbb_.AddOffset(InfoRequest::VT_ERROR, error);
+ }
+ void add_features(rpc::Feature features) {
+ fbb_.AddElement<uint64_t>(InfoRequest::VT_FEATURES, static_cast<uint64_t>(features), 0);
+ }
+ void add_globs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::GlobInfo>>> globs) {
+ fbb_.AddOffset(InfoRequest::VT_GLOBS, globs);
+ }
+ void add_files(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::FileInfo>>> files) {
+ fbb_.AddOffset(InfoRequest::VT_FILES, files);
+ }
+ explicit InfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<InfoRequest> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<InfoRequest>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<InfoRequest> CreateInfoRequest(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::String> error = 0,
+ rpc::Feature features = static_cast<rpc::Feature>(0),
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::GlobInfo>>> globs = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::FileInfo>>> 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<InfoRequest> CreateInfoRequestDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const char *error = nullptr,
+ rpc::Feature features = static_cast<rpc::Feature>(0),
+ const std::vector<flatbuffers::Offset<rpc::GlobInfo>> *globs = nullptr,
+ const std::vector<flatbuffers::Offset<rpc::FileInfo>> *files = nullptr) {
+ auto error__ = error ? _fbb.CreateString(error) : 0;
+ auto globs__ = globs ? _fbb.CreateVector<flatbuffers::Offset<rpc::GlobInfo>>(*globs) : 0;
+ auto files__ = files ? _fbb.CreateVector<flatbuffers::Offset<rpc::FileInfo>>(*files) : 0;
+ return rpc::CreateInfoRequest(
+ _fbb,
+ error__,
+ features,
+ globs__,
+ files__);
+}
+
+flatbuffers::Offset<InfoRequest> CreateInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct InfoReplyT : public flatbuffers::NativeTable {
+ typedef InfoReply TableType;
+ std::vector<uint32_t> 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<uint32_t> *cover_filter() const {
+ return GetPointer<const flatbuffers::Vector<uint32_t> *>(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<InfoReply> 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<flatbuffers::Vector<uint32_t>> cover_filter) {
+ fbb_.AddOffset(InfoReply::VT_COVER_FILTER, cover_filter);
+ }
+ explicit InfoReplyBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<InfoReply> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<InfoReply>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<InfoReply> CreateInfoReply(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<uint32_t>> cover_filter = 0) {
+ InfoReplyBuilder builder_(_fbb);
+ builder_.add_cover_filter(cover_filter);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<InfoReply> CreateInfoReplyDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<uint32_t> *cover_filter = nullptr) {
+ auto cover_filter__ = cover_filter ? _fbb.CreateVector<uint32_t>(*cover_filter) : 0;
+ return rpc::CreateInfoReply(
+ _fbb,
+ cover_filter__);
+}
+
+flatbuffers::Offset<InfoReply> 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<uint8_t> 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<const flatbuffers::String *>(VT_NAME);
+ }
+ bool exists() const {
+ return GetField<uint8_t>(VT_EXISTS, 0) != 0;
+ }
+ const flatbuffers::String *error() const {
+ return GetPointer<const flatbuffers::String *>(VT_ERROR);
+ }
+ const flatbuffers::Vector<uint8_t> *data() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyOffset(verifier, VT_NAME) &&
+ verifier.VerifyString(name()) &&
+ VerifyField<uint8_t>(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<FileInfo> 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<flatbuffers::String> name) {
+ fbb_.AddOffset(FileInfo::VT_NAME, name);
+ }
+ void add_exists(bool exists) {
+ fbb_.AddElement<uint8_t>(FileInfo::VT_EXISTS, static_cast<uint8_t>(exists), 0);
+ }
+ void add_error(flatbuffers::Offset<flatbuffers::String> error) {
+ fbb_.AddOffset(FileInfo::VT_ERROR, error);
+ }
+ void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
+ fbb_.AddOffset(FileInfo::VT_DATA, data);
+ }
+ explicit FileInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<FileInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<FileInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<FileInfo> CreateFileInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::String> name = 0,
+ bool exists = false,
+ flatbuffers::Offset<flatbuffers::String> error = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> 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<FileInfo> CreateFileInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const char *name = nullptr,
+ bool exists = false,
+ const char *error = nullptr,
+ const std::vector<uint8_t> *data = nullptr) {
+ auto name__ = name ? _fbb.CreateString(name) : 0;
+ auto error__ = error ? _fbb.CreateString(error) : 0;
+ auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
+ return rpc::CreateFileInfo(
+ _fbb,
+ name__,
+ exists,
+ error__,
+ data__);
+}
+
+flatbuffers::Offset<FileInfo> 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<std::string> 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<const flatbuffers::String *>(VT_NAME);
+ }
+ const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *files() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(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<GlobInfo> 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<flatbuffers::String> name) {
+ fbb_.AddOffset(GlobInfo::VT_NAME, name);
+ }
+ void add_files(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> files) {
+ fbb_.AddOffset(GlobInfo::VT_FILES, files);
+ }
+ explicit GlobInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<GlobInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<GlobInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<GlobInfo> CreateGlobInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::String> name = 0,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> files = 0) {
+ GlobInfoBuilder builder_(_fbb);
+ builder_.add_files(files);
+ builder_.add_name(name);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<GlobInfo> CreateGlobInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const char *name = nullptr,
+ const std::vector<flatbuffers::Offset<flatbuffers::String>> *files = nullptr) {
+ auto name__ = name ? _fbb.CreateString(name) : 0;
+ auto files__ = files ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*files) : 0;
+ return rpc::CreateGlobInfo(
+ _fbb,
+ name__,
+ files__);
+}
+
+flatbuffers::Offset<GlobInfo> 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<rpc::HostMessages>(GetField<uint8_t>(VT_MSG_TYPE, 0));
+ }
+ const void *msg() const {
+ return GetPointer<const void *>(VT_MSG);
+ }
+ template<typename T> const T *msg_as() const;
+ const rpc::ExecRequest *msg_as_ExecRequest() const {
+ return msg_type() == rpc::HostMessages::ExecRequest ? static_cast<const rpc::ExecRequest *>(msg()) : nullptr;
+ }
+ const rpc::SignalUpdate *msg_as_SignalUpdate() const {
+ return msg_type() == rpc::HostMessages::SignalUpdate ? static_cast<const rpc::SignalUpdate *>(msg()) : nullptr;
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint8_t>(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<HostMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+template<> inline const rpc::ExecRequest *HostMessage::msg_as<rpc::ExecRequest>() const {
+ return msg_as_ExecRequest();
+}
+
+template<> inline const rpc::SignalUpdate *HostMessage::msg_as<rpc::SignalUpdate>() 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<uint8_t>(HostMessage::VT_MSG_TYPE, static_cast<uint8_t>(msg_type), 0);
+ }
+ void add_msg(flatbuffers::Offset<void> msg) {
+ fbb_.AddOffset(HostMessage::VT_MSG, msg);
+ }
+ explicit HostMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<HostMessage> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<HostMessage>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<HostMessage> CreateHostMessage(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ rpc::HostMessages msg_type = rpc::HostMessages::NONE,
+ flatbuffers::Offset<void> msg = 0) {
+ HostMessageBuilder builder_(_fbb);
+ builder_.add_msg(msg);
+ builder_.add_msg_type(msg_type);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<HostMessage> 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<rpc::ExecutorMessages>(GetField<uint8_t>(VT_MSG_TYPE, 0));
+ }
+ const void *msg() const {
+ return GetPointer<const void *>(VT_MSG);
+ }
+ template<typename T> const T *msg_as() const;
+ const rpc::ExecResult *msg_as_ExecResult() const {
+ return msg_type() == rpc::ExecutorMessages::ExecResult ? static_cast<const rpc::ExecResult *>(msg()) : nullptr;
+ }
+ const rpc::ExecutingMessage *msg_as_Executing() const {
+ return msg_type() == rpc::ExecutorMessages::Executing ? static_cast<const rpc::ExecutingMessage *>(msg()) : nullptr;
+ }
+ const rpc::StatsMessage *msg_as_Stats() const {
+ return msg_type() == rpc::ExecutorMessages::Stats ? static_cast<const rpc::StatsMessage *>(msg()) : nullptr;
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint8_t>(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<ExecutorMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+};
+
+template<> inline const rpc::ExecResult *ExecutorMessage::msg_as<rpc::ExecResult>() const {
+ return msg_as_ExecResult();
+}
+
+template<> inline const rpc::ExecutingMessage *ExecutorMessage::msg_as<rpc::ExecutingMessage>() const {
+ return msg_as_Executing();
+}
+
+template<> inline const rpc::StatsMessage *ExecutorMessage::msg_as<rpc::StatsMessage>() 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<uint8_t>(ExecutorMessage::VT_MSG_TYPE, static_cast<uint8_t>(msg_type), 0);
+ }
+ void add_msg(flatbuffers::Offset<void> msg) {
+ fbb_.AddOffset(ExecutorMessage::VT_MSG, msg);
+ }
+ explicit ExecutorMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<ExecutorMessage> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<ExecutorMessage>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<ExecutorMessage> CreateExecutorMessage(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ rpc::ExecutorMessages msg_type = rpc::ExecutorMessages::NONE,
+ flatbuffers::Offset<void> msg = 0) {
+ ExecutorMessageBuilder builder_(_fbb);
+ builder_.add_msg(msg);
+ builder_.add_msg_type(msg_type);
+ return builder_.Finish();
+}
+
+flatbuffers::Offset<ExecutorMessage> 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<uint8_t> prog_data{};
+ rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0);
+ rpc::ExecEnv exec_env = static_cast<rpc::ExecEnv>(0);
+ rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0);
+ int64_t sandbox_arg = 0;
+ std::vector<uint32_t> 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<int64_t>(VT_ID, 0);
+ }
+ const flatbuffers::Vector<uint8_t> *prog_data() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_PROG_DATA);
+ }
+ rpc::RequestFlag flags() const {
+ return static_cast<rpc::RequestFlag>(GetField<uint64_t>(VT_FLAGS, 0));
+ }
+ rpc::ExecEnv exec_env() const {
+ return static_cast<rpc::ExecEnv>(GetField<uint64_t>(VT_EXEC_ENV, 0));
+ }
+ rpc::ExecFlag exec_flags() const {
+ return static_cast<rpc::ExecFlag>(GetField<uint64_t>(VT_EXEC_FLAGS, 0));
+ }
+ int64_t sandbox_arg() const {
+ return GetField<int64_t>(VT_SANDBOX_ARG, 0);
+ }
+ const flatbuffers::Vector<uint32_t> *signal_filter() const {
+ return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIGNAL_FILTER);
+ }
+ int32_t signal_filter_call() const {
+ return GetField<int32_t>(VT_SIGNAL_FILTER_CALL, 0);
+ }
+ int32_t repeat() const {
+ return GetField<int32_t>(VT_REPEAT, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_ID, 8) &&
+ VerifyOffset(verifier, VT_PROG_DATA) &&
+ verifier.VerifyVector(prog_data()) &&
+ VerifyField<uint64_t>(verifier, VT_FLAGS, 8) &&
+ VerifyField<uint64_t>(verifier, VT_EXEC_ENV, 8) &&
+ VerifyField<uint64_t>(verifier, VT_EXEC_FLAGS, 8) &&
+ VerifyField<int64_t>(verifier, VT_SANDBOX_ARG, 8) &&
+ VerifyOffset(verifier, VT_SIGNAL_FILTER) &&
+ verifier.VerifyVector(signal_filter()) &&
+ VerifyField<int32_t>(verifier, VT_SIGNAL_FILTER_CALL, 4) &&
+ VerifyField<int32_t>(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<ExecRequest> 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<int64_t>(ExecRequest::VT_ID, id, 0);
+ }
+ void add_prog_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> prog_data) {
+ fbb_.AddOffset(ExecRequest::VT_PROG_DATA, prog_data);
+ }
+ void add_flags(rpc::RequestFlag flags) {
+ fbb_.AddElement<uint64_t>(ExecRequest::VT_FLAGS, static_cast<uint64_t>(flags), 0);
+ }
+ void add_exec_env(rpc::ExecEnv exec_env) {
+ fbb_.AddElement<uint64_t>(ExecRequest::VT_EXEC_ENV, static_cast<uint64_t>(exec_env), 0);
+ }
+ void add_exec_flags(rpc::ExecFlag exec_flags) {
+ fbb_.AddElement<uint64_t>(ExecRequest::VT_EXEC_FLAGS, static_cast<uint64_t>(exec_flags), 0);
+ }
+ void add_sandbox_arg(int64_t sandbox_arg) {
+ fbb_.AddElement<int64_t>(ExecRequest::VT_SANDBOX_ARG, sandbox_arg, 0);
+ }
+ void add_signal_filter(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal_filter) {
+ fbb_.AddOffset(ExecRequest::VT_SIGNAL_FILTER, signal_filter);
+ }
+ void add_signal_filter_call(int32_t signal_filter_call) {
+ fbb_.AddElement<int32_t>(ExecRequest::VT_SIGNAL_FILTER_CALL, signal_filter_call, 0);
+ }
+ void add_repeat(int32_t repeat) {
+ fbb_.AddElement<int32_t>(ExecRequest::VT_REPEAT, repeat, 0);
+ }
+ explicit ExecRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<ExecRequest> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<ExecRequest>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<ExecRequest> CreateExecRequest(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t id = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> prog_data = 0,
+ rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0),
+ rpc::ExecEnv exec_env = static_cast<rpc::ExecEnv>(0),
+ rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0),
+ int64_t sandbox_arg = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint32_t>> 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<ExecRequest> CreateExecRequestDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ int64_t id = 0,
+ const std::vector<uint8_t> *prog_data = nullptr,
+ rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0),
+ rpc::ExecEnv exec_env = static_cast<rpc::ExecEnv>(0),
+ rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0),
+ int64_t sandbox_arg = 0,
+ const std::vector<uint32_t> *signal_filter = nullptr,
+ int32_t signal_filter_call = 0,
+ int32_t repeat = 0) {
+ auto prog_data__ = prog_data ? _fbb.CreateVector<uint8_t>(*prog_data) : 0;
+ auto signal_filter__ = signal_filter ? _fbb.CreateVector<uint32_t>(*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<ExecRequest> CreateExecRequest(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct SignalUpdateT : public flatbuffers::NativeTable {
+ typedef SignalUpdate TableType;
+ std::vector<uint32_t> new_max{};
+ std::vector<uint32_t> 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<uint32_t> *new_max() const {
+ return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_NEW_MAX);
+ }
+ const flatbuffers::Vector<uint32_t> *drop_max() const {
+ return GetPointer<const flatbuffers::Vector<uint32_t> *>(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<SignalUpdate> 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<flatbuffers::Vector<uint32_t>> new_max) {
+ fbb_.AddOffset(SignalUpdate::VT_NEW_MAX, new_max);
+ }
+ void add_drop_max(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> drop_max) {
+ fbb_.AddOffset(SignalUpdate::VT_DROP_MAX, drop_max);
+ }
+ explicit SignalUpdateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<SignalUpdate> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<SignalUpdate>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<SignalUpdate> CreateSignalUpdate(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<uint32_t>> new_max = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint32_t>> drop_max = 0) {
+ SignalUpdateBuilder builder_(_fbb);
+ builder_.add_drop_max(drop_max);
+ builder_.add_new_max(new_max);
+ return builder_.Finish();
+}
+
+inline flatbuffers::Offset<SignalUpdate> CreateSignalUpdateDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<uint32_t> *new_max = nullptr,
+ const std::vector<uint32_t> *drop_max = nullptr) {
+ auto new_max__ = new_max ? _fbb.CreateVector<uint32_t>(*new_max) : 0;
+ auto drop_max__ = drop_max ? _fbb.CreateVector<uint32_t>(*drop_max) : 0;
+ return rpc::CreateSignalUpdate(
+ _fbb,
+ new_max__,
+ drop_max__);
+}
+
+flatbuffers::Offset<SignalUpdate> 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<int64_t>(VT_ID, 0);
+ }
+ int32_t proc_id() const {
+ return GetField<int32_t>(VT_PROC_ID, 0);
+ }
+ int32_t try_() const {
+ return GetField<int32_t>(VT_TRY_, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_ID, 8) &&
+ VerifyField<int32_t>(verifier, VT_PROC_ID, 4) &&
+ VerifyField<int32_t>(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<ExecutingMessage> 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<int64_t>(ExecutingMessage::VT_ID, id, 0);
+ }
+ void add_proc_id(int32_t proc_id) {
+ fbb_.AddElement<int32_t>(ExecutingMessage::VT_PROC_ID, proc_id, 0);
+ }
+ void add_try_(int32_t try_) {
+ fbb_.AddElement<int32_t>(ExecutingMessage::VT_TRY_, try_, 0);
+ }
+ explicit ExecutingMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<ExecutingMessage> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<ExecutingMessage>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<ExecutingMessage> 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<ExecutingMessage> 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<int64_t>(VT_NOEXEC_COUNT, 0);
+ }
+ int64_t noexec_duration() const {
+ return GetField<int64_t>(VT_NOEXEC_DURATION, 0);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<int64_t>(verifier, VT_NOEXEC_COUNT, 8) &&
+ VerifyField<int64_t>(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<StatsMessage> 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<int64_t>(StatsMessage::VT_NOEXEC_COUNT, noexec_count, 0);
+ }
+ void add_noexec_duration(int64_t noexec_duration) {
+ fbb_.AddElement<int64_t>(StatsMessage::VT_NOEXEC_DURATION, noexec_duration, 0);
+ }
+ explicit StatsMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<StatsMessage> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<StatsMessage>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<StatsMessage> 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<StatsMessage> 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<rpc::CallFlag>(0);
+ int32_t error = 0;
+ std::vector<uint32_t> signal{};
+ std::vector<uint32_t> cover{};
+ std::vector<rpc::Comparison> 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<rpc::CallFlag>(GetField<uint8_t>(VT_FLAGS, 0));
+ }
+ int32_t error() const {
+ return GetField<int32_t>(VT_ERROR, 0);
+ }
+ const flatbuffers::Vector<uint32_t> *signal() const {
+ return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_SIGNAL);
+ }
+ const flatbuffers::Vector<uint32_t> *cover() const {
+ return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_COVER);
+ }
+ const flatbuffers::Vector<const rpc::Comparison *> *comps() const {
+ return GetPointer<const flatbuffers::Vector<const rpc::Comparison *> *>(VT_COMPS);
+ }
+ bool Verify(flatbuffers::Verifier &verifier) const {
+ return VerifyTableStart(verifier) &&
+ VerifyField<uint8_t>(verifier, VT_FLAGS, 1) &&
+ VerifyField<int32_t>(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<CallInfo> 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<uint8_t>(CallInfo::VT_FLAGS, static_cast<uint8_t>(flags), 0);
+ }
+ void add_error(int32_t error) {
+ fbb_.AddElement<int32_t>(CallInfo::VT_ERROR, error, 0);
+ }
+ void add_signal(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal) {
+ fbb_.AddOffset(CallInfo::VT_SIGNAL, signal);
+ }
+ void add_cover(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> cover) {
+ fbb_.AddOffset(CallInfo::VT_COVER, cover);
+ }
+ void add_comps(flatbuffers::Offset<flatbuffers::Vector<const rpc::Comparison *>> comps) {
+ fbb_.AddOffset(CallInfo::VT_COMPS, comps);
+ }
+ explicit CallInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<CallInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<CallInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<CallInfo> CreateCallInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ rpc::CallFlag flags = static_cast<rpc::CallFlag>(0),
+ int32_t error = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint32_t>> signal = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint32_t>> cover = 0,
+ flatbuffers::Offset<flatbuffers::Vector<const rpc::Comparison *>> 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<CallInfo> CreateCallInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ rpc::CallFlag flags = static_cast<rpc::CallFlag>(0),
+ int32_t error = 0,
+ const std::vector<uint32_t> *signal = nullptr,
+ const std::vector<uint32_t> *cover = nullptr,
+ const std::vector<rpc::Comparison> *comps = nullptr) {
+ auto signal__ = signal ? _fbb.CreateVector<uint32_t>(*signal) : 0;
+ auto cover__ = cover ? _fbb.CreateVector<uint32_t>(*cover) : 0;
+ auto comps__ = comps ? _fbb.CreateVectorOfStructs<rpc::Comparison>(*comps) : 0;
+ return rpc::CreateCallInfo(
+ _fbb,
+ flags,
+ error,
+ signal__,
+ cover__,
+ comps__);
+}
+
+flatbuffers::Offset<CallInfo> CreateCallInfo(flatbuffers::FlatBufferBuilder &_fbb, const CallInfoT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
+
+struct ProgInfoT : public flatbuffers::NativeTable {
+ typedef ProgInfo TableType;
+ std::vector<std::unique_ptr<rpc::CallInfoT>> calls{};
+ std::unique_ptr<rpc::CallInfoT> 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<flatbuffers::Offset<rpc::CallInfo>> *calls() const {
+ return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfo>> *>(VT_CALLS);
+ }
+ const rpc::CallInfo *extra() const {
+ return GetPointer<const rpc::CallInfo *>(VT_EXTRA);
+ }
+ uint64_t elapsed() const {
+ return GetField<uint64_t>(VT_ELAPSED, 0);
+ }
+ uint64_t freshness() const {
+ return GetField<uint64_t>(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<uint64_t>(verifier, VT_ELAPSED, 8) &&
+ VerifyField<uint64_t>(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<ProgInfo> 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<flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfo>>> calls) {
+ fbb_.AddOffset(ProgInfo::VT_CALLS, calls);
+ }
+ void add_extra(flatbuffers::Offset<rpc::CallInfo> extra) {
+ fbb_.AddOffset(ProgInfo::VT_EXTRA, extra);
+ }
+ void add_elapsed(uint64_t elapsed) {
+ fbb_.AddElement<uint64_t>(ProgInfo::VT_ELAPSED, elapsed, 0);
+ }
+ void add_freshness(uint64_t freshness) {
+ fbb_.AddElement<uint64_t>(ProgInfo::VT_FRESHNESS, freshness, 0);
+ }
+ explicit ProgInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<ProgInfo> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<ProgInfo>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<ProgInfo> CreateProgInfo(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<rpc::CallInfo>>> calls = 0,
+ flatbuffers::Offset<rpc::CallInfo> 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<ProgInfo> CreateProgInfoDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ const std::vector<flatbuffers::Offset<rpc::CallInfo>> *calls = nullptr,
+ flatbuffers::Offset<rpc::CallInfo> extra = 0,
+ uint64_t elapsed = 0,
+ uint64_t freshness = 0) {
+ auto calls__ = calls ? _fbb.CreateVector<flatbuffers::Offset<rpc::CallInfo>>(*calls) : 0;
+ return rpc::CreateProgInfo(
+ _fbb,
+ calls__,
+ extra,
+ elapsed,
+ freshness);
+}
+
+flatbuffers::Offset<ProgInfo> 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<rpc::ExecutingMessageT> executing{};
+ std::vector<uint8_t> output{};
+ std::string error{};
+ std::unique_ptr<rpc::ProgInfoT> 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<const rpc::ExecutingMessage *>(VT_EXECUTING);
+ }
+ const flatbuffers::Vector<uint8_t> *output() const {
+ return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_OUTPUT);
+ }
+ const flatbuffers::String *error() const {
+ return GetPointer<const flatbuffers::String *>(VT_ERROR);
+ }
+ const rpc::ProgInfo *info() const {
+ return GetPointer<const rpc::ProgInfo *>(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<ExecResult> 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<rpc::ExecutingMessage> executing) {
+ fbb_.AddOffset(ExecResult::VT_EXECUTING, executing);
+ }
+ void add_output(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output) {
+ fbb_.AddOffset(ExecResult::VT_OUTPUT, output);
+ }
+ void add_error(flatbuffers::Offset<flatbuffers::String> error) {
+ fbb_.AddOffset(ExecResult::VT_ERROR, error);
+ }
+ void add_info(flatbuffers::Offset<rpc::ProgInfo> info) {
+ fbb_.AddOffset(ExecResult::VT_INFO, info);
+ }
+ explicit ExecResultBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+ : fbb_(_fbb) {
+ start_ = fbb_.StartTable();
+ }
+ flatbuffers::Offset<ExecResult> Finish() {
+ const auto end = fbb_.EndTable(start_);
+ auto o = flatbuffers::Offset<ExecResult>(end);
+ return o;
+ }
+};
+
+inline flatbuffers::Offset<ExecResult> CreateExecResult(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<rpc::ExecutingMessage> executing = 0,
+ flatbuffers::Offset<flatbuffers::Vector<uint8_t>> output = 0,
+ flatbuffers::Offset<flatbuffers::String> error = 0,
+ flatbuffers::Offset<rpc::ProgInfo> 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<ExecResult> CreateExecResultDirect(
+ flatbuffers::FlatBufferBuilder &_fbb,
+ flatbuffers::Offset<rpc::ExecutingMessage> executing = 0,
+ const std::vector<uint8_t> *output = nullptr,
+ const char *error = nullptr,
+ flatbuffers::Offset<rpc::ProgInfo> info = 0) {
+ auto output__ = output ? _fbb.CreateVector<uint8_t>(*output) : 0;
+ auto error__ = error ? _fbb.CreateString(error) : 0;
+ return rpc::CreateExecResult(
+ _fbb,
+ executing,
+ output__,
+ error__,
+ info);
+}
+
+flatbuffers::Offset<ExecResult> 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<ConnectRequestT>(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> ConnectRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateConnectRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ConnectRequest> 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<ConnectReplyT>(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> ConnectReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateConnectReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ConnectReply> 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<InfoRequestT>(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<rpc::GlobInfoT>(_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<rpc::FileInfoT>(_e->Get(_i)->UnPack(_resolver)); } } }
+}
+
+inline flatbuffers::Offset<InfoRequest> InfoRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateInfoRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<InfoRequest> 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<flatbuffers::Offset<rpc::GlobInfo>> (_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<flatbuffers::Offset<rpc::FileInfo>> (_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<InfoReplyT>(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> InfoReply::Pack(flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateInfoReply(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<InfoReply> 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<FileInfoT>(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> FileInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FileInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateFileInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<FileInfo> 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<GlobInfoT>(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> GlobInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateGlobInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<GlobInfo> 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<HostMessageT>(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> HostMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HostMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateHostMessage(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<HostMessage> 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<ExecutorMessageT>(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> ExecutorMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateExecutorMessage(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ExecutorMessage> 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<ExecRequestT>(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> ExecRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateExecRequest(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ExecRequest> 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<SignalUpdateT>(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> SignalUpdate::Pack(flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateSignalUpdate(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<SignalUpdate> 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<ExecutingMessageT>(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> ExecutingMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateExecutingMessage(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ExecutingMessage> 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<StatsMessageT>(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> StatsMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const StatsMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateStatsMessage(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<StatsMessage> 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<CallInfoT>(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> CallInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const CallInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateCallInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<CallInfo> 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<ProgInfoT>(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<rpc::CallInfoT>(_e->Get(_i)->UnPack(_resolver)); } } }
+ { auto _e = extra(); if (_e) _o->extra = std::unique_ptr<rpc::CallInfoT>(_e->UnPack(_resolver)); }
+ { auto _e = elapsed(); _o->elapsed = _e; }
+ { auto _e = freshness(); _o->freshness = _e; }
+}
+
+inline flatbuffers::Offset<ProgInfo> ProgInfo::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateProgInfo(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ProgInfo> 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<flatbuffers::Offset<rpc::CallInfo>> (_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<ExecResultT>(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<rpc::ExecutingMessageT>(_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<rpc::ProgInfoT>(_e->UnPack(_resolver)); }
+}
+
+inline flatbuffers::Offset<ExecResult> ExecResult::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ExecResultT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
+ return CreateExecResult(_fbb, _o, _rehasher);
+}
+
+inline flatbuffers::Offset<ExecResult> 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<const rpc::ExecRequest *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case HostMessages::SignalUpdate: {
+ auto ptr = reinterpret_cast<const rpc::SignalUpdate *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ default: return true;
+ }
+}
+
+inline bool VerifyHostMessagesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<HostMessages> *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<HostMessages>(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<const rpc::ExecRequest *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case HostMessages::SignalUpdate: {
+ auto ptr = reinterpret_cast<const rpc::SignalUpdate *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ default: return nullptr;
+ }
+}
+
+inline flatbuffers::Offset<void> HostMessagesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+ (void)_rehasher;
+ switch (type) {
+ case HostMessages::ExecRequest: {
+ auto ptr = reinterpret_cast<const rpc::ExecRequestT *>(value);
+ return CreateExecRequest(_fbb, ptr, _rehasher).Union();
+ }
+ case HostMessages::SignalUpdate: {
+ auto ptr = reinterpret_cast<const rpc::SignalUpdateT *>(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<rpc::ExecRequestT *>(u.value));
+ break;
+ }
+ case HostMessages::SignalUpdate: {
+ value = new rpc::SignalUpdateT(*reinterpret_cast<rpc::SignalUpdateT *>(u.value));
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+inline void HostMessagesUnion::Reset() {
+ switch (type) {
+ case HostMessages::ExecRequest: {
+ auto ptr = reinterpret_cast<rpc::ExecRequestT *>(value);
+ delete ptr;
+ break;
+ }
+ case HostMessages::SignalUpdate: {
+ auto ptr = reinterpret_cast<rpc::SignalUpdateT *>(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<const rpc::ExecResult *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ExecutorMessages::Executing: {
+ auto ptr = reinterpret_cast<const rpc::ExecutingMessage *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ case ExecutorMessages::Stats: {
+ auto ptr = reinterpret_cast<const rpc::StatsMessage *>(obj);
+ return verifier.VerifyTable(ptr);
+ }
+ default: return true;
+ }
+}
+
+inline bool VerifyExecutorMessagesVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<ExecutorMessages> *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<ExecutorMessages>(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<const rpc::ExecResult *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ExecutorMessages::Executing: {
+ auto ptr = reinterpret_cast<const rpc::ExecutingMessage *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ case ExecutorMessages::Stats: {
+ auto ptr = reinterpret_cast<const rpc::StatsMessage *>(obj);
+ return ptr->UnPack(resolver);
+ }
+ default: return nullptr;
+ }
+}
+
+inline flatbuffers::Offset<void> ExecutorMessagesUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
+ (void)_rehasher;
+ switch (type) {
+ case ExecutorMessages::ExecResult: {
+ auto ptr = reinterpret_cast<const rpc::ExecResultT *>(value);
+ return CreateExecResult(_fbb, ptr, _rehasher).Union();
+ }
+ case ExecutorMessages::Executing: {
+ auto ptr = reinterpret_cast<const rpc::ExecutingMessageT *>(value);
+ return CreateExecutingMessage(_fbb, ptr, _rehasher).Union();
+ }
+ case ExecutorMessages::Stats: {
+ auto ptr = reinterpret_cast<const rpc::StatsMessageT *>(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<rpc::ExecResultT *>(u.value));
+ break;
+ }
+ case ExecutorMessages::Executing: {
+ value = new rpc::ExecutingMessageT(*reinterpret_cast<rpc::ExecutingMessageT *>(u.value));
+ break;
+ }
+ case ExecutorMessages::Stats: {
+ value = new rpc::StatsMessageT(*reinterpret_cast<rpc::StatsMessageT *>(u.value));
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+inline void ExecutorMessagesUnion::Reset() {
+ switch (type) {
+ case ExecutorMessages::ExecResult: {
+ auto ptr = reinterpret_cast<rpc::ExecResultT *>(value);
+ delete ptr;
+ break;
+ }
+ case ExecutorMessages::Executing: {
+ auto ptr = reinterpret_cast<rpc::ExecutingMessageT *>(value);
+ delete ptr;
+ break;
+ }
+ case ExecutorMessages::Stats: {
+ auto ptr = reinterpret_cast<rpc::StatsMessageT *>(value);
+ delete ptr;
+ break;
+ }
+ default: break;
+ }
+ value = nullptr;
+ type = ExecutorMessages::NONE;
+}
+
+} // namespace rpc
+
+#endif // FLATBUFFERS_GENERATED_FLATRPC_RPC_H_
generated by ggit (джигит) mrf-deployment (git 2.46.0) at 2026-03-11 23:02:33 +0000