github.com/google/syzkaller@v0.0.0-20251211124644-a066d2bc4b02/pkg/flatrpc/flatrpc.h (about) 1 // automatically generated by the FlatBuffers compiler, do not modify 2 3 4 #ifndef FLATBUFFERS_GENERATED_FLATRPC_RPC_H_ 5 #define FLATBUFFERS_GENERATED_FLATRPC_RPC_H_ 6 7 #include "flatbuffers/flatbuffers.h" 8 9 // Ensure the included flatbuffers.h is the same version as when this file was 10 // generated, otherwise it may not be compatible. 11 static_assert(FLATBUFFERS_VERSION_MAJOR == 23 && 12 FLATBUFFERS_VERSION_MINOR == 5 && 13 FLATBUFFERS_VERSION_REVISION == 26, 14 "Non-compatible flatbuffers version included"); 15 16 namespace rpc { 17 18 struct ConnectHelloRaw; 19 struct ConnectHelloRawBuilder; 20 struct ConnectHelloRawT; 21 22 struct ConnectRequestRaw; 23 struct ConnectRequestRawBuilder; 24 struct ConnectRequestRawT; 25 26 struct ConnectReplyRaw; 27 struct ConnectReplyRawBuilder; 28 struct ConnectReplyRawT; 29 30 struct InfoRequestRaw; 31 struct InfoRequestRawBuilder; 32 struct InfoRequestRawT; 33 34 struct InfoReplyRaw; 35 struct InfoReplyRawBuilder; 36 struct InfoReplyRawT; 37 38 struct FileInfoRaw; 39 struct FileInfoRawBuilder; 40 struct FileInfoRawT; 41 42 struct GlobInfoRaw; 43 struct GlobInfoRawBuilder; 44 struct GlobInfoRawT; 45 46 struct FeatureInfoRaw; 47 struct FeatureInfoRawBuilder; 48 struct FeatureInfoRawT; 49 50 struct HostMessageRaw; 51 struct HostMessageRawBuilder; 52 struct HostMessageRawT; 53 54 struct ExecutorMessageRaw; 55 struct ExecutorMessageRawBuilder; 56 struct ExecutorMessageRawT; 57 58 struct ExecOptsRaw; 59 60 struct ExecRequestRaw; 61 struct ExecRequestRawBuilder; 62 struct ExecRequestRawT; 63 64 struct SignalUpdateRaw; 65 struct SignalUpdateRawBuilder; 66 struct SignalUpdateRawT; 67 68 struct CorpusTriagedRaw; 69 struct CorpusTriagedRawBuilder; 70 struct CorpusTriagedRawT; 71 72 struct StateRequestRaw; 73 struct StateRequestRawBuilder; 74 struct StateRequestRawT; 75 76 struct ExecutingMessageRaw; 77 struct ExecutingMessageRawBuilder; 78 struct ExecutingMessageRawT; 79 80 struct CallInfoRaw; 81 struct CallInfoRawBuilder; 82 struct CallInfoRawT; 83 84 struct ComparisonRaw; 85 86 struct ProgInfoRaw; 87 struct ProgInfoRawBuilder; 88 struct ProgInfoRawT; 89 90 struct ExecResultRaw; 91 struct ExecResultRawBuilder; 92 struct ExecResultRawT; 93 94 struct StateResultRaw; 95 struct StateResultRawBuilder; 96 struct StateResultRawT; 97 98 struct SnapshotHeader; 99 struct SnapshotHeaderBuilder; 100 struct SnapshotHeaderT; 101 102 struct SnapshotHandshake; 103 struct SnapshotHandshakeBuilder; 104 struct SnapshotHandshakeT; 105 106 struct SnapshotRequest; 107 struct SnapshotRequestBuilder; 108 struct SnapshotRequestT; 109 110 enum class Const : uint64_t { 111 SnapshotDoorbellSize = 4096ULL, 112 MaxInputSize = 4198400ULL, 113 MaxOutputSize = 14680064ULL, 114 SnapshotShmemSize = 33554432ULL, 115 MIN = SnapshotDoorbellSize, 116 MAX = SnapshotShmemSize 117 }; 118 119 inline const Const (&EnumValuesConst())[4] { 120 static const Const values[] = { 121 Const::SnapshotDoorbellSize, 122 Const::MaxInputSize, 123 Const::MaxOutputSize, 124 Const::SnapshotShmemSize 125 }; 126 return values; 127 } 128 129 inline const char *EnumNameConst(Const e) { 130 switch (e) { 131 case Const::SnapshotDoorbellSize: return "SnapshotDoorbellSize"; 132 case Const::MaxInputSize: return "MaxInputSize"; 133 case Const::MaxOutputSize: return "MaxOutputSize"; 134 case Const::SnapshotShmemSize: return "SnapshotShmemSize"; 135 default: return ""; 136 } 137 } 138 139 enum class Feature : uint64_t { 140 Coverage = 1ULL, 141 Comparisons = 2ULL, 142 ExtraCoverage = 4ULL, 143 DelayKcovMmap = 8ULL, 144 KcovResetIoctl = 16ULL, 145 SandboxNone = 32ULL, 146 SandboxSetuid = 64ULL, 147 SandboxNamespace = 128ULL, 148 SandboxAndroid = 256ULL, 149 Fault = 512ULL, 150 Leak = 1024ULL, 151 NetInjection = 2048ULL, 152 NetDevices = 4096ULL, 153 KCSAN = 8192ULL, 154 DevlinkPCI = 16384ULL, 155 NicVF = 32768ULL, 156 USBEmulation = 65536ULL, 157 VhciInjection = 131072ULL, 158 WifiEmulation = 262144ULL, 159 LRWPANEmulation = 524288ULL, 160 BinFmtMisc = 1048576ULL, 161 Swap = 2097152ULL, 162 NONE = 0, 163 ANY = 4194303ULL 164 }; 165 FLATBUFFERS_DEFINE_BITMASK_OPERATORS(Feature, uint64_t) 166 167 inline const Feature (&EnumValuesFeature())[22] { 168 static const Feature values[] = { 169 Feature::Coverage, 170 Feature::Comparisons, 171 Feature::ExtraCoverage, 172 Feature::DelayKcovMmap, 173 Feature::KcovResetIoctl, 174 Feature::SandboxNone, 175 Feature::SandboxSetuid, 176 Feature::SandboxNamespace, 177 Feature::SandboxAndroid, 178 Feature::Fault, 179 Feature::Leak, 180 Feature::NetInjection, 181 Feature::NetDevices, 182 Feature::KCSAN, 183 Feature::DevlinkPCI, 184 Feature::NicVF, 185 Feature::USBEmulation, 186 Feature::VhciInjection, 187 Feature::WifiEmulation, 188 Feature::LRWPANEmulation, 189 Feature::BinFmtMisc, 190 Feature::Swap 191 }; 192 return values; 193 } 194 195 inline const char *EnumNameFeature(Feature e) { 196 switch (e) { 197 case Feature::Coverage: return "Coverage"; 198 case Feature::Comparisons: return "Comparisons"; 199 case Feature::ExtraCoverage: return "ExtraCoverage"; 200 case Feature::DelayKcovMmap: return "DelayKcovMmap"; 201 case Feature::KcovResetIoctl: return "KcovResetIoctl"; 202 case Feature::SandboxNone: return "SandboxNone"; 203 case Feature::SandboxSetuid: return "SandboxSetuid"; 204 case Feature::SandboxNamespace: return "SandboxNamespace"; 205 case Feature::SandboxAndroid: return "SandboxAndroid"; 206 case Feature::Fault: return "Fault"; 207 case Feature::Leak: return "Leak"; 208 case Feature::NetInjection: return "NetInjection"; 209 case Feature::NetDevices: return "NetDevices"; 210 case Feature::KCSAN: return "KCSAN"; 211 case Feature::DevlinkPCI: return "DevlinkPCI"; 212 case Feature::NicVF: return "NicVF"; 213 case Feature::USBEmulation: return "USBEmulation"; 214 case Feature::VhciInjection: return "VhciInjection"; 215 case Feature::WifiEmulation: return "WifiEmulation"; 216 case Feature::LRWPANEmulation: return "LRWPANEmulation"; 217 case Feature::BinFmtMisc: return "BinFmtMisc"; 218 case Feature::Swap: return "Swap"; 219 default: return ""; 220 } 221 } 222 223 enum class HostMessagesRaw : uint8_t { 224 NONE = 0, 225 ExecRequest = 1, 226 SignalUpdate = 2, 227 CorpusTriaged = 3, 228 StateRequest = 4, 229 MIN = NONE, 230 MAX = StateRequest 231 }; 232 233 inline const HostMessagesRaw (&EnumValuesHostMessagesRaw())[5] { 234 static const HostMessagesRaw values[] = { 235 HostMessagesRaw::NONE, 236 HostMessagesRaw::ExecRequest, 237 HostMessagesRaw::SignalUpdate, 238 HostMessagesRaw::CorpusTriaged, 239 HostMessagesRaw::StateRequest 240 }; 241 return values; 242 } 243 244 inline const char * const *EnumNamesHostMessagesRaw() { 245 static const char * const names[6] = { 246 "NONE", 247 "ExecRequest", 248 "SignalUpdate", 249 "CorpusTriaged", 250 "StateRequest", 251 nullptr 252 }; 253 return names; 254 } 255 256 inline const char *EnumNameHostMessagesRaw(HostMessagesRaw e) { 257 if (::flatbuffers::IsOutRange(e, HostMessagesRaw::NONE, HostMessagesRaw::StateRequest)) return ""; 258 const size_t index = static_cast<size_t>(e); 259 return EnumNamesHostMessagesRaw()[index]; 260 } 261 262 template<typename T> struct HostMessagesRawTraits { 263 static const HostMessagesRaw enum_value = HostMessagesRaw::NONE; 264 }; 265 266 template<> struct HostMessagesRawTraits<rpc::ExecRequestRaw> { 267 static const HostMessagesRaw enum_value = HostMessagesRaw::ExecRequest; 268 }; 269 270 template<> struct HostMessagesRawTraits<rpc::SignalUpdateRaw> { 271 static const HostMessagesRaw enum_value = HostMessagesRaw::SignalUpdate; 272 }; 273 274 template<> struct HostMessagesRawTraits<rpc::CorpusTriagedRaw> { 275 static const HostMessagesRaw enum_value = HostMessagesRaw::CorpusTriaged; 276 }; 277 278 template<> struct HostMessagesRawTraits<rpc::StateRequestRaw> { 279 static const HostMessagesRaw enum_value = HostMessagesRaw::StateRequest; 280 }; 281 282 template<typename T> struct HostMessagesRawUnionTraits { 283 static const HostMessagesRaw enum_value = HostMessagesRaw::NONE; 284 }; 285 286 template<> struct HostMessagesRawUnionTraits<rpc::ExecRequestRawT> { 287 static const HostMessagesRaw enum_value = HostMessagesRaw::ExecRequest; 288 }; 289 290 template<> struct HostMessagesRawUnionTraits<rpc::SignalUpdateRawT> { 291 static const HostMessagesRaw enum_value = HostMessagesRaw::SignalUpdate; 292 }; 293 294 template<> struct HostMessagesRawUnionTraits<rpc::CorpusTriagedRawT> { 295 static const HostMessagesRaw enum_value = HostMessagesRaw::CorpusTriaged; 296 }; 297 298 template<> struct HostMessagesRawUnionTraits<rpc::StateRequestRawT> { 299 static const HostMessagesRaw enum_value = HostMessagesRaw::StateRequest; 300 }; 301 302 struct HostMessagesRawUnion { 303 HostMessagesRaw type; 304 void *value; 305 306 HostMessagesRawUnion() : type(HostMessagesRaw::NONE), value(nullptr) {} 307 HostMessagesRawUnion(HostMessagesRawUnion&& u) FLATBUFFERS_NOEXCEPT : 308 type(HostMessagesRaw::NONE), value(nullptr) 309 { std::swap(type, u.type); std::swap(value, u.value); } 310 HostMessagesRawUnion(const HostMessagesRawUnion &); 311 HostMessagesRawUnion &operator=(const HostMessagesRawUnion &u) 312 { HostMessagesRawUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } 313 HostMessagesRawUnion &operator=(HostMessagesRawUnion &&u) FLATBUFFERS_NOEXCEPT 314 { std::swap(type, u.type); std::swap(value, u.value); return *this; } 315 ~HostMessagesRawUnion() { Reset(); } 316 317 void Reset(); 318 319 template <typename T> 320 void Set(T&& val) { 321 typedef typename std::remove_reference<T>::type RT; 322 Reset(); 323 type = HostMessagesRawUnionTraits<RT>::enum_value; 324 if (type != HostMessagesRaw::NONE) { 325 value = new RT(std::forward<T>(val)); 326 } 327 } 328 329 static void *UnPack(const void *obj, HostMessagesRaw type, const ::flatbuffers::resolver_function_t *resolver); 330 ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 331 332 rpc::ExecRequestRawT *AsExecRequest() { 333 return type == HostMessagesRaw::ExecRequest ? 334 reinterpret_cast<rpc::ExecRequestRawT *>(value) : nullptr; 335 } 336 const rpc::ExecRequestRawT *AsExecRequest() const { 337 return type == HostMessagesRaw::ExecRequest ? 338 reinterpret_cast<const rpc::ExecRequestRawT *>(value) : nullptr; 339 } 340 rpc::SignalUpdateRawT *AsSignalUpdate() { 341 return type == HostMessagesRaw::SignalUpdate ? 342 reinterpret_cast<rpc::SignalUpdateRawT *>(value) : nullptr; 343 } 344 const rpc::SignalUpdateRawT *AsSignalUpdate() const { 345 return type == HostMessagesRaw::SignalUpdate ? 346 reinterpret_cast<const rpc::SignalUpdateRawT *>(value) : nullptr; 347 } 348 rpc::CorpusTriagedRawT *AsCorpusTriaged() { 349 return type == HostMessagesRaw::CorpusTriaged ? 350 reinterpret_cast<rpc::CorpusTriagedRawT *>(value) : nullptr; 351 } 352 const rpc::CorpusTriagedRawT *AsCorpusTriaged() const { 353 return type == HostMessagesRaw::CorpusTriaged ? 354 reinterpret_cast<const rpc::CorpusTriagedRawT *>(value) : nullptr; 355 } 356 rpc::StateRequestRawT *AsStateRequest() { 357 return type == HostMessagesRaw::StateRequest ? 358 reinterpret_cast<rpc::StateRequestRawT *>(value) : nullptr; 359 } 360 const rpc::StateRequestRawT *AsStateRequest() const { 361 return type == HostMessagesRaw::StateRequest ? 362 reinterpret_cast<const rpc::StateRequestRawT *>(value) : nullptr; 363 } 364 }; 365 366 bool VerifyHostMessagesRaw(::flatbuffers::Verifier &verifier, const void *obj, HostMessagesRaw type); 367 bool VerifyHostMessagesRawVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<HostMessagesRaw> *types); 368 369 enum class ExecutorMessagesRaw : uint8_t { 370 NONE = 0, 371 ExecResult = 1, 372 Executing = 2, 373 State = 3, 374 MIN = NONE, 375 MAX = State 376 }; 377 378 inline const ExecutorMessagesRaw (&EnumValuesExecutorMessagesRaw())[4] { 379 static const ExecutorMessagesRaw values[] = { 380 ExecutorMessagesRaw::NONE, 381 ExecutorMessagesRaw::ExecResult, 382 ExecutorMessagesRaw::Executing, 383 ExecutorMessagesRaw::State 384 }; 385 return values; 386 } 387 388 inline const char * const *EnumNamesExecutorMessagesRaw() { 389 static const char * const names[5] = { 390 "NONE", 391 "ExecResult", 392 "Executing", 393 "State", 394 nullptr 395 }; 396 return names; 397 } 398 399 inline const char *EnumNameExecutorMessagesRaw(ExecutorMessagesRaw e) { 400 if (::flatbuffers::IsOutRange(e, ExecutorMessagesRaw::NONE, ExecutorMessagesRaw::State)) return ""; 401 const size_t index = static_cast<size_t>(e); 402 return EnumNamesExecutorMessagesRaw()[index]; 403 } 404 405 template<typename T> struct ExecutorMessagesRawTraits { 406 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::NONE; 407 }; 408 409 template<> struct ExecutorMessagesRawTraits<rpc::ExecResultRaw> { 410 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::ExecResult; 411 }; 412 413 template<> struct ExecutorMessagesRawTraits<rpc::ExecutingMessageRaw> { 414 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::Executing; 415 }; 416 417 template<> struct ExecutorMessagesRawTraits<rpc::StateResultRaw> { 418 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::State; 419 }; 420 421 template<typename T> struct ExecutorMessagesRawUnionTraits { 422 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::NONE; 423 }; 424 425 template<> struct ExecutorMessagesRawUnionTraits<rpc::ExecResultRawT> { 426 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::ExecResult; 427 }; 428 429 template<> struct ExecutorMessagesRawUnionTraits<rpc::ExecutingMessageRawT> { 430 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::Executing; 431 }; 432 433 template<> struct ExecutorMessagesRawUnionTraits<rpc::StateResultRawT> { 434 static const ExecutorMessagesRaw enum_value = ExecutorMessagesRaw::State; 435 }; 436 437 struct ExecutorMessagesRawUnion { 438 ExecutorMessagesRaw type; 439 void *value; 440 441 ExecutorMessagesRawUnion() : type(ExecutorMessagesRaw::NONE), value(nullptr) {} 442 ExecutorMessagesRawUnion(ExecutorMessagesRawUnion&& u) FLATBUFFERS_NOEXCEPT : 443 type(ExecutorMessagesRaw::NONE), value(nullptr) 444 { std::swap(type, u.type); std::swap(value, u.value); } 445 ExecutorMessagesRawUnion(const ExecutorMessagesRawUnion &); 446 ExecutorMessagesRawUnion &operator=(const ExecutorMessagesRawUnion &u) 447 { ExecutorMessagesRawUnion t(u); std::swap(type, t.type); std::swap(value, t.value); return *this; } 448 ExecutorMessagesRawUnion &operator=(ExecutorMessagesRawUnion &&u) FLATBUFFERS_NOEXCEPT 449 { std::swap(type, u.type); std::swap(value, u.value); return *this; } 450 ~ExecutorMessagesRawUnion() { Reset(); } 451 452 void Reset(); 453 454 template <typename T> 455 void Set(T&& val) { 456 typedef typename std::remove_reference<T>::type RT; 457 Reset(); 458 type = ExecutorMessagesRawUnionTraits<RT>::enum_value; 459 if (type != ExecutorMessagesRaw::NONE) { 460 value = new RT(std::forward<T>(val)); 461 } 462 } 463 464 static void *UnPack(const void *obj, ExecutorMessagesRaw type, const ::flatbuffers::resolver_function_t *resolver); 465 ::flatbuffers::Offset<void> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 466 467 rpc::ExecResultRawT *AsExecResult() { 468 return type == ExecutorMessagesRaw::ExecResult ? 469 reinterpret_cast<rpc::ExecResultRawT *>(value) : nullptr; 470 } 471 const rpc::ExecResultRawT *AsExecResult() const { 472 return type == ExecutorMessagesRaw::ExecResult ? 473 reinterpret_cast<const rpc::ExecResultRawT *>(value) : nullptr; 474 } 475 rpc::ExecutingMessageRawT *AsExecuting() { 476 return type == ExecutorMessagesRaw::Executing ? 477 reinterpret_cast<rpc::ExecutingMessageRawT *>(value) : nullptr; 478 } 479 const rpc::ExecutingMessageRawT *AsExecuting() const { 480 return type == ExecutorMessagesRaw::Executing ? 481 reinterpret_cast<const rpc::ExecutingMessageRawT *>(value) : nullptr; 482 } 483 rpc::StateResultRawT *AsState() { 484 return type == ExecutorMessagesRaw::State ? 485 reinterpret_cast<rpc::StateResultRawT *>(value) : nullptr; 486 } 487 const rpc::StateResultRawT *AsState() const { 488 return type == ExecutorMessagesRaw::State ? 489 reinterpret_cast<const rpc::StateResultRawT *>(value) : nullptr; 490 } 491 }; 492 493 bool VerifyExecutorMessagesRaw(::flatbuffers::Verifier &verifier, const void *obj, ExecutorMessagesRaw type); 494 bool VerifyExecutorMessagesRawVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ExecutorMessagesRaw> *types); 495 496 enum class RequestType : uint64_t { 497 Program = 0, 498 Binary = 1ULL, 499 Glob = 2ULL, 500 MIN = Program, 501 MAX = Glob 502 }; 503 504 inline const RequestType (&EnumValuesRequestType())[3] { 505 static const RequestType values[] = { 506 RequestType::Program, 507 RequestType::Binary, 508 RequestType::Glob 509 }; 510 return values; 511 } 512 513 inline const char * const *EnumNamesRequestType() { 514 static const char * const names[4] = { 515 "Program", 516 "Binary", 517 "Glob", 518 nullptr 519 }; 520 return names; 521 } 522 523 inline const char *EnumNameRequestType(RequestType e) { 524 if (::flatbuffers::IsOutRange(e, RequestType::Program, RequestType::Glob)) return ""; 525 const size_t index = static_cast<size_t>(e); 526 return EnumNamesRequestType()[index]; 527 } 528 529 enum class RequestFlag : uint64_t { 530 ReturnOutput = 1ULL, 531 ReturnError = 2ULL, 532 NONE = 0, 533 ANY = 3ULL 534 }; 535 FLATBUFFERS_DEFINE_BITMASK_OPERATORS(RequestFlag, uint64_t) 536 537 inline const RequestFlag (&EnumValuesRequestFlag())[2] { 538 static const RequestFlag values[] = { 539 RequestFlag::ReturnOutput, 540 RequestFlag::ReturnError 541 }; 542 return values; 543 } 544 545 inline const char * const *EnumNamesRequestFlag() { 546 static const char * const names[3] = { 547 "ReturnOutput", 548 "ReturnError", 549 nullptr 550 }; 551 return names; 552 } 553 554 inline const char *EnumNameRequestFlag(RequestFlag e) { 555 if (::flatbuffers::IsOutRange(e, RequestFlag::ReturnOutput, RequestFlag::ReturnError)) return ""; 556 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(RequestFlag::ReturnOutput); 557 return EnumNamesRequestFlag()[index]; 558 } 559 560 enum class ExecEnv : uint64_t { 561 Debug = 1ULL, 562 Signal = 2ULL, 563 ReadOnlyCoverage = 4ULL, 564 ResetState = 8ULL, 565 SandboxNone = 16ULL, 566 SandboxSetuid = 32ULL, 567 SandboxNamespace = 64ULL, 568 SandboxAndroid = 128ULL, 569 ExtraCover = 256ULL, 570 EnableTun = 512ULL, 571 EnableNetDev = 1024ULL, 572 EnableNetReset = 2048ULL, 573 EnableCgroups = 4096ULL, 574 EnableCloseFds = 8192ULL, 575 EnableDevlinkPCI = 16384ULL, 576 EnableVhciInjection = 32768ULL, 577 EnableWifi = 65536ULL, 578 DelayKcovMmap = 131072ULL, 579 EnableNicVF = 262144ULL, 580 NONE = 0, 581 ANY = 524287ULL 582 }; 583 FLATBUFFERS_DEFINE_BITMASK_OPERATORS(ExecEnv, uint64_t) 584 585 inline const ExecEnv (&EnumValuesExecEnv())[19] { 586 static const ExecEnv values[] = { 587 ExecEnv::Debug, 588 ExecEnv::Signal, 589 ExecEnv::ReadOnlyCoverage, 590 ExecEnv::ResetState, 591 ExecEnv::SandboxNone, 592 ExecEnv::SandboxSetuid, 593 ExecEnv::SandboxNamespace, 594 ExecEnv::SandboxAndroid, 595 ExecEnv::ExtraCover, 596 ExecEnv::EnableTun, 597 ExecEnv::EnableNetDev, 598 ExecEnv::EnableNetReset, 599 ExecEnv::EnableCgroups, 600 ExecEnv::EnableCloseFds, 601 ExecEnv::EnableDevlinkPCI, 602 ExecEnv::EnableVhciInjection, 603 ExecEnv::EnableWifi, 604 ExecEnv::DelayKcovMmap, 605 ExecEnv::EnableNicVF 606 }; 607 return values; 608 } 609 610 inline const char *EnumNameExecEnv(ExecEnv e) { 611 switch (e) { 612 case ExecEnv::Debug: return "Debug"; 613 case ExecEnv::Signal: return "Signal"; 614 case ExecEnv::ReadOnlyCoverage: return "ReadOnlyCoverage"; 615 case ExecEnv::ResetState: return "ResetState"; 616 case ExecEnv::SandboxNone: return "SandboxNone"; 617 case ExecEnv::SandboxSetuid: return "SandboxSetuid"; 618 case ExecEnv::SandboxNamespace: return "SandboxNamespace"; 619 case ExecEnv::SandboxAndroid: return "SandboxAndroid"; 620 case ExecEnv::ExtraCover: return "ExtraCover"; 621 case ExecEnv::EnableTun: return "EnableTun"; 622 case ExecEnv::EnableNetDev: return "EnableNetDev"; 623 case ExecEnv::EnableNetReset: return "EnableNetReset"; 624 case ExecEnv::EnableCgroups: return "EnableCgroups"; 625 case ExecEnv::EnableCloseFds: return "EnableCloseFds"; 626 case ExecEnv::EnableDevlinkPCI: return "EnableDevlinkPCI"; 627 case ExecEnv::EnableVhciInjection: return "EnableVhciInjection"; 628 case ExecEnv::EnableWifi: return "EnableWifi"; 629 case ExecEnv::DelayKcovMmap: return "DelayKcovMmap"; 630 case ExecEnv::EnableNicVF: return "EnableNicVF"; 631 default: return ""; 632 } 633 } 634 635 enum class ExecFlag : uint64_t { 636 CollectSignal = 1ULL, 637 CollectCover = 2ULL, 638 DedupCover = 4ULL, 639 CollectComps = 8ULL, 640 Threaded = 16ULL, 641 NONE = 0, 642 ANY = 31ULL 643 }; 644 FLATBUFFERS_DEFINE_BITMASK_OPERATORS(ExecFlag, uint64_t) 645 646 inline const ExecFlag (&EnumValuesExecFlag())[5] { 647 static const ExecFlag values[] = { 648 ExecFlag::CollectSignal, 649 ExecFlag::CollectCover, 650 ExecFlag::DedupCover, 651 ExecFlag::CollectComps, 652 ExecFlag::Threaded 653 }; 654 return values; 655 } 656 657 inline const char * const *EnumNamesExecFlag() { 658 static const char * const names[17] = { 659 "CollectSignal", 660 "CollectCover", 661 "", 662 "DedupCover", 663 "", 664 "", 665 "", 666 "CollectComps", 667 "", 668 "", 669 "", 670 "", 671 "", 672 "", 673 "", 674 "Threaded", 675 nullptr 676 }; 677 return names; 678 } 679 680 inline const char *EnumNameExecFlag(ExecFlag e) { 681 if (::flatbuffers::IsOutRange(e, ExecFlag::CollectSignal, ExecFlag::Threaded)) return ""; 682 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(ExecFlag::CollectSignal); 683 return EnumNamesExecFlag()[index]; 684 } 685 686 enum class CallFlag : uint8_t { 687 Executed = 1, 688 Finished = 2, 689 Blocked = 4, 690 FaultInjected = 8, 691 CoverageOverflow = 16, 692 NONE = 0, 693 ANY = 31 694 }; 695 FLATBUFFERS_DEFINE_BITMASK_OPERATORS(CallFlag, uint8_t) 696 697 inline const CallFlag (&EnumValuesCallFlag())[5] { 698 static const CallFlag values[] = { 699 CallFlag::Executed, 700 CallFlag::Finished, 701 CallFlag::Blocked, 702 CallFlag::FaultInjected, 703 CallFlag::CoverageOverflow 704 }; 705 return values; 706 } 707 708 inline const char * const *EnumNamesCallFlag() { 709 static const char * const names[17] = { 710 "Executed", 711 "Finished", 712 "", 713 "Blocked", 714 "", 715 "", 716 "", 717 "FaultInjected", 718 "", 719 "", 720 "", 721 "", 722 "", 723 "", 724 "", 725 "CoverageOverflow", 726 nullptr 727 }; 728 return names; 729 } 730 731 inline const char *EnumNameCallFlag(CallFlag e) { 732 if (::flatbuffers::IsOutRange(e, CallFlag::Executed, CallFlag::CoverageOverflow)) return ""; 733 const size_t index = static_cast<size_t>(e) - static_cast<size_t>(CallFlag::Executed); 734 return EnumNamesCallFlag()[index]; 735 } 736 737 enum class SnapshotState : uint64_t { 738 Initial = 0, 739 Handshake = 1ULL, 740 Ready = 2ULL, 741 Snapshotted = 3ULL, 742 Execute = 4ULL, 743 Executed = 5ULL, 744 Failed = 6ULL, 745 MIN = Initial, 746 MAX = Failed 747 }; 748 749 inline const SnapshotState (&EnumValuesSnapshotState())[7] { 750 static const SnapshotState values[] = { 751 SnapshotState::Initial, 752 SnapshotState::Handshake, 753 SnapshotState::Ready, 754 SnapshotState::Snapshotted, 755 SnapshotState::Execute, 756 SnapshotState::Executed, 757 SnapshotState::Failed 758 }; 759 return values; 760 } 761 762 inline const char * const *EnumNamesSnapshotState() { 763 static const char * const names[8] = { 764 "Initial", 765 "Handshake", 766 "Ready", 767 "Snapshotted", 768 "Execute", 769 "Executed", 770 "Failed", 771 nullptr 772 }; 773 return names; 774 } 775 776 inline const char *EnumNameSnapshotState(SnapshotState e) { 777 if (::flatbuffers::IsOutRange(e, SnapshotState::Initial, SnapshotState::Failed)) return ""; 778 const size_t index = static_cast<size_t>(e); 779 return EnumNamesSnapshotState()[index]; 780 } 781 782 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ExecOptsRaw FLATBUFFERS_FINAL_CLASS { 783 private: 784 uint64_t env_flags_; 785 uint64_t exec_flags_; 786 int64_t sandbox_arg_; 787 788 public: 789 ExecOptsRaw() 790 : env_flags_(0), 791 exec_flags_(0), 792 sandbox_arg_(0) { 793 } 794 ExecOptsRaw(rpc::ExecEnv _env_flags, rpc::ExecFlag _exec_flags, int64_t _sandbox_arg) 795 : env_flags_(::flatbuffers::EndianScalar(static_cast<uint64_t>(_env_flags))), 796 exec_flags_(::flatbuffers::EndianScalar(static_cast<uint64_t>(_exec_flags))), 797 sandbox_arg_(::flatbuffers::EndianScalar(_sandbox_arg)) { 798 } 799 rpc::ExecEnv env_flags() const { 800 return static_cast<rpc::ExecEnv>(::flatbuffers::EndianScalar(env_flags_)); 801 } 802 rpc::ExecFlag exec_flags() const { 803 return static_cast<rpc::ExecFlag>(::flatbuffers::EndianScalar(exec_flags_)); 804 } 805 int64_t sandbox_arg() const { 806 return ::flatbuffers::EndianScalar(sandbox_arg_); 807 } 808 }; 809 FLATBUFFERS_STRUCT_END(ExecOptsRaw, 24); 810 811 FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) ComparisonRaw FLATBUFFERS_FINAL_CLASS { 812 private: 813 uint64_t pc_; 814 uint64_t op1_; 815 uint64_t op2_; 816 uint8_t is_const_; 817 int8_t padding0__; int16_t padding1__; int32_t padding2__; 818 819 public: 820 ComparisonRaw() 821 : pc_(0), 822 op1_(0), 823 op2_(0), 824 is_const_(0), 825 padding0__(0), 826 padding1__(0), 827 padding2__(0) { 828 (void)padding0__; 829 (void)padding1__; 830 (void)padding2__; 831 } 832 ComparisonRaw(uint64_t _pc, uint64_t _op1, uint64_t _op2, bool _is_const) 833 : pc_(::flatbuffers::EndianScalar(_pc)), 834 op1_(::flatbuffers::EndianScalar(_op1)), 835 op2_(::flatbuffers::EndianScalar(_op2)), 836 is_const_(::flatbuffers::EndianScalar(static_cast<uint8_t>(_is_const))), 837 padding0__(0), 838 padding1__(0), 839 padding2__(0) { 840 (void)padding0__; 841 (void)padding1__; 842 (void)padding2__; 843 } 844 uint64_t pc() const { 845 return ::flatbuffers::EndianScalar(pc_); 846 } 847 uint64_t op1() const { 848 return ::flatbuffers::EndianScalar(op1_); 849 } 850 uint64_t op2() const { 851 return ::flatbuffers::EndianScalar(op2_); 852 } 853 bool is_const() const { 854 return ::flatbuffers::EndianScalar(is_const_) != 0; 855 } 856 }; 857 FLATBUFFERS_STRUCT_END(ComparisonRaw, 32); 858 859 struct ConnectHelloRawT : public ::flatbuffers::NativeTable { 860 typedef ConnectHelloRaw TableType; 861 uint64_t cookie = 0; 862 }; 863 864 struct ConnectHelloRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 865 typedef ConnectHelloRawT NativeTableType; 866 typedef ConnectHelloRawBuilder Builder; 867 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 868 VT_COOKIE = 4 869 }; 870 uint64_t cookie() const { 871 return GetField<uint64_t>(VT_COOKIE, 0); 872 } 873 bool Verify(::flatbuffers::Verifier &verifier) const { 874 return VerifyTableStart(verifier) && 875 VerifyField<uint64_t>(verifier, VT_COOKIE, 8) && 876 verifier.EndTable(); 877 } 878 ConnectHelloRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 879 void UnPackTo(ConnectHelloRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 880 static ::flatbuffers::Offset<ConnectHelloRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectHelloRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 881 }; 882 883 struct ConnectHelloRawBuilder { 884 typedef ConnectHelloRaw Table; 885 ::flatbuffers::FlatBufferBuilder &fbb_; 886 ::flatbuffers::uoffset_t start_; 887 void add_cookie(uint64_t cookie) { 888 fbb_.AddElement<uint64_t>(ConnectHelloRaw::VT_COOKIE, cookie, 0); 889 } 890 explicit ConnectHelloRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 891 : fbb_(_fbb) { 892 start_ = fbb_.StartTable(); 893 } 894 ::flatbuffers::Offset<ConnectHelloRaw> Finish() { 895 const auto end = fbb_.EndTable(start_); 896 auto o = ::flatbuffers::Offset<ConnectHelloRaw>(end); 897 return o; 898 } 899 }; 900 901 inline ::flatbuffers::Offset<ConnectHelloRaw> CreateConnectHelloRaw( 902 ::flatbuffers::FlatBufferBuilder &_fbb, 903 uint64_t cookie = 0) { 904 ConnectHelloRawBuilder builder_(_fbb); 905 builder_.add_cookie(cookie); 906 return builder_.Finish(); 907 } 908 909 ::flatbuffers::Offset<ConnectHelloRaw> CreateConnectHelloRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectHelloRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 910 911 struct ConnectRequestRawT : public ::flatbuffers::NativeTable { 912 typedef ConnectRequestRaw TableType; 913 uint64_t cookie = 0; 914 int64_t id = 0; 915 std::string arch{}; 916 std::string git_revision{}; 917 std::string syz_revision{}; 918 }; 919 920 struct ConnectRequestRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 921 typedef ConnectRequestRawT NativeTableType; 922 typedef ConnectRequestRawBuilder Builder; 923 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 924 VT_COOKIE = 4, 925 VT_ID = 6, 926 VT_ARCH = 8, 927 VT_GIT_REVISION = 10, 928 VT_SYZ_REVISION = 12 929 }; 930 uint64_t cookie() const { 931 return GetField<uint64_t>(VT_COOKIE, 0); 932 } 933 int64_t id() const { 934 return GetField<int64_t>(VT_ID, 0); 935 } 936 const ::flatbuffers::String *arch() const { 937 return GetPointer<const ::flatbuffers::String *>(VT_ARCH); 938 } 939 const ::flatbuffers::String *git_revision() const { 940 return GetPointer<const ::flatbuffers::String *>(VT_GIT_REVISION); 941 } 942 const ::flatbuffers::String *syz_revision() const { 943 return GetPointer<const ::flatbuffers::String *>(VT_SYZ_REVISION); 944 } 945 bool Verify(::flatbuffers::Verifier &verifier) const { 946 return VerifyTableStart(verifier) && 947 VerifyField<uint64_t>(verifier, VT_COOKIE, 8) && 948 VerifyField<int64_t>(verifier, VT_ID, 8) && 949 VerifyOffset(verifier, VT_ARCH) && 950 verifier.VerifyString(arch()) && 951 VerifyOffset(verifier, VT_GIT_REVISION) && 952 verifier.VerifyString(git_revision()) && 953 VerifyOffset(verifier, VT_SYZ_REVISION) && 954 verifier.VerifyString(syz_revision()) && 955 verifier.EndTable(); 956 } 957 ConnectRequestRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 958 void UnPackTo(ConnectRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 959 static ::flatbuffers::Offset<ConnectRequestRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 960 }; 961 962 struct ConnectRequestRawBuilder { 963 typedef ConnectRequestRaw Table; 964 ::flatbuffers::FlatBufferBuilder &fbb_; 965 ::flatbuffers::uoffset_t start_; 966 void add_cookie(uint64_t cookie) { 967 fbb_.AddElement<uint64_t>(ConnectRequestRaw::VT_COOKIE, cookie, 0); 968 } 969 void add_id(int64_t id) { 970 fbb_.AddElement<int64_t>(ConnectRequestRaw::VT_ID, id, 0); 971 } 972 void add_arch(::flatbuffers::Offset<::flatbuffers::String> arch) { 973 fbb_.AddOffset(ConnectRequestRaw::VT_ARCH, arch); 974 } 975 void add_git_revision(::flatbuffers::Offset<::flatbuffers::String> git_revision) { 976 fbb_.AddOffset(ConnectRequestRaw::VT_GIT_REVISION, git_revision); 977 } 978 void add_syz_revision(::flatbuffers::Offset<::flatbuffers::String> syz_revision) { 979 fbb_.AddOffset(ConnectRequestRaw::VT_SYZ_REVISION, syz_revision); 980 } 981 explicit ConnectRequestRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 982 : fbb_(_fbb) { 983 start_ = fbb_.StartTable(); 984 } 985 ::flatbuffers::Offset<ConnectRequestRaw> Finish() { 986 const auto end = fbb_.EndTable(start_); 987 auto o = ::flatbuffers::Offset<ConnectRequestRaw>(end); 988 return o; 989 } 990 }; 991 992 inline ::flatbuffers::Offset<ConnectRequestRaw> CreateConnectRequestRaw( 993 ::flatbuffers::FlatBufferBuilder &_fbb, 994 uint64_t cookie = 0, 995 int64_t id = 0, 996 ::flatbuffers::Offset<::flatbuffers::String> arch = 0, 997 ::flatbuffers::Offset<::flatbuffers::String> git_revision = 0, 998 ::flatbuffers::Offset<::flatbuffers::String> syz_revision = 0) { 999 ConnectRequestRawBuilder builder_(_fbb); 1000 builder_.add_id(id); 1001 builder_.add_cookie(cookie); 1002 builder_.add_syz_revision(syz_revision); 1003 builder_.add_git_revision(git_revision); 1004 builder_.add_arch(arch); 1005 return builder_.Finish(); 1006 } 1007 1008 inline ::flatbuffers::Offset<ConnectRequestRaw> CreateConnectRequestRawDirect( 1009 ::flatbuffers::FlatBufferBuilder &_fbb, 1010 uint64_t cookie = 0, 1011 int64_t id = 0, 1012 const char *arch = nullptr, 1013 const char *git_revision = nullptr, 1014 const char *syz_revision = nullptr) { 1015 auto arch__ = arch ? _fbb.CreateString(arch) : 0; 1016 auto git_revision__ = git_revision ? _fbb.CreateString(git_revision) : 0; 1017 auto syz_revision__ = syz_revision ? _fbb.CreateString(syz_revision) : 0; 1018 return rpc::CreateConnectRequestRaw( 1019 _fbb, 1020 cookie, 1021 id, 1022 arch__, 1023 git_revision__, 1024 syz_revision__); 1025 } 1026 1027 ::flatbuffers::Offset<ConnectRequestRaw> CreateConnectRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1028 1029 struct ConnectReplyRawT : public ::flatbuffers::NativeTable { 1030 typedef ConnectReplyRaw TableType; 1031 bool debug = false; 1032 bool cover = false; 1033 bool cover_edges = false; 1034 bool kernel_64_bit = false; 1035 int32_t procs = 0; 1036 int32_t slowdown = 0; 1037 int32_t syscall_timeout_ms = 0; 1038 int32_t program_timeout_ms = 0; 1039 std::vector<std::string> leak_frames{}; 1040 std::vector<std::string> race_frames{}; 1041 rpc::Feature features = static_cast<rpc::Feature>(0); 1042 std::vector<std::string> files{}; 1043 }; 1044 1045 struct ConnectReplyRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1046 typedef ConnectReplyRawT NativeTableType; 1047 typedef ConnectReplyRawBuilder Builder; 1048 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1049 VT_DEBUG = 4, 1050 VT_COVER = 6, 1051 VT_COVER_EDGES = 8, 1052 VT_KERNEL_64_BIT = 10, 1053 VT_PROCS = 12, 1054 VT_SLOWDOWN = 14, 1055 VT_SYSCALL_TIMEOUT_MS = 16, 1056 VT_PROGRAM_TIMEOUT_MS = 18, 1057 VT_LEAK_FRAMES = 20, 1058 VT_RACE_FRAMES = 22, 1059 VT_FEATURES = 24, 1060 VT_FILES = 26 1061 }; 1062 bool debug() const { 1063 return GetField<uint8_t>(VT_DEBUG, 0) != 0; 1064 } 1065 bool cover() const { 1066 return GetField<uint8_t>(VT_COVER, 0) != 0; 1067 } 1068 bool cover_edges() const { 1069 return GetField<uint8_t>(VT_COVER_EDGES, 0) != 0; 1070 } 1071 bool kernel_64_bit() const { 1072 return GetField<uint8_t>(VT_KERNEL_64_BIT, 0) != 0; 1073 } 1074 int32_t procs() const { 1075 return GetField<int32_t>(VT_PROCS, 0); 1076 } 1077 int32_t slowdown() const { 1078 return GetField<int32_t>(VT_SLOWDOWN, 0); 1079 } 1080 int32_t syscall_timeout_ms() const { 1081 return GetField<int32_t>(VT_SYSCALL_TIMEOUT_MS, 0); 1082 } 1083 int32_t program_timeout_ms() const { 1084 return GetField<int32_t>(VT_PROGRAM_TIMEOUT_MS, 0); 1085 } 1086 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *leak_frames() const { 1087 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_LEAK_FRAMES); 1088 } 1089 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *race_frames() const { 1090 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_RACE_FRAMES); 1091 } 1092 rpc::Feature features() const { 1093 return static_cast<rpc::Feature>(GetField<uint64_t>(VT_FEATURES, 0)); 1094 } 1095 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *files() const { 1096 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_FILES); 1097 } 1098 bool Verify(::flatbuffers::Verifier &verifier) const { 1099 return VerifyTableStart(verifier) && 1100 VerifyField<uint8_t>(verifier, VT_DEBUG, 1) && 1101 VerifyField<uint8_t>(verifier, VT_COVER, 1) && 1102 VerifyField<uint8_t>(verifier, VT_COVER_EDGES, 1) && 1103 VerifyField<uint8_t>(verifier, VT_KERNEL_64_BIT, 1) && 1104 VerifyField<int32_t>(verifier, VT_PROCS, 4) && 1105 VerifyField<int32_t>(verifier, VT_SLOWDOWN, 4) && 1106 VerifyField<int32_t>(verifier, VT_SYSCALL_TIMEOUT_MS, 4) && 1107 VerifyField<int32_t>(verifier, VT_PROGRAM_TIMEOUT_MS, 4) && 1108 VerifyOffset(verifier, VT_LEAK_FRAMES) && 1109 verifier.VerifyVector(leak_frames()) && 1110 verifier.VerifyVectorOfStrings(leak_frames()) && 1111 VerifyOffset(verifier, VT_RACE_FRAMES) && 1112 verifier.VerifyVector(race_frames()) && 1113 verifier.VerifyVectorOfStrings(race_frames()) && 1114 VerifyField<uint64_t>(verifier, VT_FEATURES, 8) && 1115 VerifyOffset(verifier, VT_FILES) && 1116 verifier.VerifyVector(files()) && 1117 verifier.VerifyVectorOfStrings(files()) && 1118 verifier.EndTable(); 1119 } 1120 ConnectReplyRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1121 void UnPackTo(ConnectReplyRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1122 static ::flatbuffers::Offset<ConnectReplyRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1123 }; 1124 1125 struct ConnectReplyRawBuilder { 1126 typedef ConnectReplyRaw Table; 1127 ::flatbuffers::FlatBufferBuilder &fbb_; 1128 ::flatbuffers::uoffset_t start_; 1129 void add_debug(bool debug) { 1130 fbb_.AddElement<uint8_t>(ConnectReplyRaw::VT_DEBUG, static_cast<uint8_t>(debug), 0); 1131 } 1132 void add_cover(bool cover) { 1133 fbb_.AddElement<uint8_t>(ConnectReplyRaw::VT_COVER, static_cast<uint8_t>(cover), 0); 1134 } 1135 void add_cover_edges(bool cover_edges) { 1136 fbb_.AddElement<uint8_t>(ConnectReplyRaw::VT_COVER_EDGES, static_cast<uint8_t>(cover_edges), 0); 1137 } 1138 void add_kernel_64_bit(bool kernel_64_bit) { 1139 fbb_.AddElement<uint8_t>(ConnectReplyRaw::VT_KERNEL_64_BIT, static_cast<uint8_t>(kernel_64_bit), 0); 1140 } 1141 void add_procs(int32_t procs) { 1142 fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_PROCS, procs, 0); 1143 } 1144 void add_slowdown(int32_t slowdown) { 1145 fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_SLOWDOWN, slowdown, 0); 1146 } 1147 void add_syscall_timeout_ms(int32_t syscall_timeout_ms) { 1148 fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_SYSCALL_TIMEOUT_MS, syscall_timeout_ms, 0); 1149 } 1150 void add_program_timeout_ms(int32_t program_timeout_ms) { 1151 fbb_.AddElement<int32_t>(ConnectReplyRaw::VT_PROGRAM_TIMEOUT_MS, program_timeout_ms, 0); 1152 } 1153 void add_leak_frames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> leak_frames) { 1154 fbb_.AddOffset(ConnectReplyRaw::VT_LEAK_FRAMES, leak_frames); 1155 } 1156 void add_race_frames(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> race_frames) { 1157 fbb_.AddOffset(ConnectReplyRaw::VT_RACE_FRAMES, race_frames); 1158 } 1159 void add_features(rpc::Feature features) { 1160 fbb_.AddElement<uint64_t>(ConnectReplyRaw::VT_FEATURES, static_cast<uint64_t>(features), 0); 1161 } 1162 void add_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> files) { 1163 fbb_.AddOffset(ConnectReplyRaw::VT_FILES, files); 1164 } 1165 explicit ConnectReplyRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1166 : fbb_(_fbb) { 1167 start_ = fbb_.StartTable(); 1168 } 1169 ::flatbuffers::Offset<ConnectReplyRaw> Finish() { 1170 const auto end = fbb_.EndTable(start_); 1171 auto o = ::flatbuffers::Offset<ConnectReplyRaw>(end); 1172 return o; 1173 } 1174 }; 1175 1176 inline ::flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw( 1177 ::flatbuffers::FlatBufferBuilder &_fbb, 1178 bool debug = false, 1179 bool cover = false, 1180 bool cover_edges = false, 1181 bool kernel_64_bit = false, 1182 int32_t procs = 0, 1183 int32_t slowdown = 0, 1184 int32_t syscall_timeout_ms = 0, 1185 int32_t program_timeout_ms = 0, 1186 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> leak_frames = 0, 1187 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> race_frames = 0, 1188 rpc::Feature features = static_cast<rpc::Feature>(0), 1189 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> files = 0) { 1190 ConnectReplyRawBuilder builder_(_fbb); 1191 builder_.add_features(features); 1192 builder_.add_files(files); 1193 builder_.add_race_frames(race_frames); 1194 builder_.add_leak_frames(leak_frames); 1195 builder_.add_program_timeout_ms(program_timeout_ms); 1196 builder_.add_syscall_timeout_ms(syscall_timeout_ms); 1197 builder_.add_slowdown(slowdown); 1198 builder_.add_procs(procs); 1199 builder_.add_kernel_64_bit(kernel_64_bit); 1200 builder_.add_cover_edges(cover_edges); 1201 builder_.add_cover(cover); 1202 builder_.add_debug(debug); 1203 return builder_.Finish(); 1204 } 1205 1206 inline ::flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRawDirect( 1207 ::flatbuffers::FlatBufferBuilder &_fbb, 1208 bool debug = false, 1209 bool cover = false, 1210 bool cover_edges = false, 1211 bool kernel_64_bit = false, 1212 int32_t procs = 0, 1213 int32_t slowdown = 0, 1214 int32_t syscall_timeout_ms = 0, 1215 int32_t program_timeout_ms = 0, 1216 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *leak_frames = nullptr, 1217 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *race_frames = nullptr, 1218 rpc::Feature features = static_cast<rpc::Feature>(0), 1219 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *files = nullptr) { 1220 auto leak_frames__ = leak_frames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*leak_frames) : 0; 1221 auto race_frames__ = race_frames ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*race_frames) : 0; 1222 auto files__ = files ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*files) : 0; 1223 return rpc::CreateConnectReplyRaw( 1224 _fbb, 1225 debug, 1226 cover, 1227 cover_edges, 1228 kernel_64_bit, 1229 procs, 1230 slowdown, 1231 syscall_timeout_ms, 1232 program_timeout_ms, 1233 leak_frames__, 1234 race_frames__, 1235 features, 1236 files__); 1237 } 1238 1239 ::flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1240 1241 struct InfoRequestRawT : public ::flatbuffers::NativeTable { 1242 typedef InfoRequestRaw TableType; 1243 std::string error{}; 1244 std::vector<std::unique_ptr<rpc::FeatureInfoRawT>> features{}; 1245 std::vector<std::unique_ptr<rpc::FileInfoRawT>> files{}; 1246 InfoRequestRawT() = default; 1247 InfoRequestRawT(const InfoRequestRawT &o); 1248 InfoRequestRawT(InfoRequestRawT&&) FLATBUFFERS_NOEXCEPT = default; 1249 InfoRequestRawT &operator=(InfoRequestRawT o) FLATBUFFERS_NOEXCEPT; 1250 }; 1251 1252 struct InfoRequestRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1253 typedef InfoRequestRawT NativeTableType; 1254 typedef InfoRequestRawBuilder Builder; 1255 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1256 VT_ERROR = 4, 1257 VT_FEATURES = 6, 1258 VT_FILES = 8 1259 }; 1260 const ::flatbuffers::String *error() const { 1261 return GetPointer<const ::flatbuffers::String *>(VT_ERROR); 1262 } 1263 const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::FeatureInfoRaw>> *features() const { 1264 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::FeatureInfoRaw>> *>(VT_FEATURES); 1265 } 1266 const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::FileInfoRaw>> *files() const { 1267 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::FileInfoRaw>> *>(VT_FILES); 1268 } 1269 bool Verify(::flatbuffers::Verifier &verifier) const { 1270 return VerifyTableStart(verifier) && 1271 VerifyOffset(verifier, VT_ERROR) && 1272 verifier.VerifyString(error()) && 1273 VerifyOffset(verifier, VT_FEATURES) && 1274 verifier.VerifyVector(features()) && 1275 verifier.VerifyVectorOfTables(features()) && 1276 VerifyOffset(verifier, VT_FILES) && 1277 verifier.VerifyVector(files()) && 1278 verifier.VerifyVectorOfTables(files()) && 1279 verifier.EndTable(); 1280 } 1281 InfoRequestRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1282 void UnPackTo(InfoRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1283 static ::flatbuffers::Offset<InfoRequestRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1284 }; 1285 1286 struct InfoRequestRawBuilder { 1287 typedef InfoRequestRaw Table; 1288 ::flatbuffers::FlatBufferBuilder &fbb_; 1289 ::flatbuffers::uoffset_t start_; 1290 void add_error(::flatbuffers::Offset<::flatbuffers::String> error) { 1291 fbb_.AddOffset(InfoRequestRaw::VT_ERROR, error); 1292 } 1293 void add_features(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::FeatureInfoRaw>>> features) { 1294 fbb_.AddOffset(InfoRequestRaw::VT_FEATURES, features); 1295 } 1296 void add_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::FileInfoRaw>>> files) { 1297 fbb_.AddOffset(InfoRequestRaw::VT_FILES, files); 1298 } 1299 explicit InfoRequestRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1300 : fbb_(_fbb) { 1301 start_ = fbb_.StartTable(); 1302 } 1303 ::flatbuffers::Offset<InfoRequestRaw> Finish() { 1304 const auto end = fbb_.EndTable(start_); 1305 auto o = ::flatbuffers::Offset<InfoRequestRaw>(end); 1306 return o; 1307 } 1308 }; 1309 1310 inline ::flatbuffers::Offset<InfoRequestRaw> CreateInfoRequestRaw( 1311 ::flatbuffers::FlatBufferBuilder &_fbb, 1312 ::flatbuffers::Offset<::flatbuffers::String> error = 0, 1313 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::FeatureInfoRaw>>> features = 0, 1314 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::FileInfoRaw>>> files = 0) { 1315 InfoRequestRawBuilder builder_(_fbb); 1316 builder_.add_files(files); 1317 builder_.add_features(features); 1318 builder_.add_error(error); 1319 return builder_.Finish(); 1320 } 1321 1322 inline ::flatbuffers::Offset<InfoRequestRaw> CreateInfoRequestRawDirect( 1323 ::flatbuffers::FlatBufferBuilder &_fbb, 1324 const char *error = nullptr, 1325 const std::vector<::flatbuffers::Offset<rpc::FeatureInfoRaw>> *features = nullptr, 1326 const std::vector<::flatbuffers::Offset<rpc::FileInfoRaw>> *files = nullptr) { 1327 auto error__ = error ? _fbb.CreateString(error) : 0; 1328 auto features__ = features ? _fbb.CreateVector<::flatbuffers::Offset<rpc::FeatureInfoRaw>>(*features) : 0; 1329 auto files__ = files ? _fbb.CreateVector<::flatbuffers::Offset<rpc::FileInfoRaw>>(*files) : 0; 1330 return rpc::CreateInfoRequestRaw( 1331 _fbb, 1332 error__, 1333 features__, 1334 files__); 1335 } 1336 1337 ::flatbuffers::Offset<InfoRequestRaw> CreateInfoRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1338 1339 struct InfoReplyRawT : public ::flatbuffers::NativeTable { 1340 typedef InfoReplyRaw TableType; 1341 std::vector<uint64_t> cover_filter{}; 1342 }; 1343 1344 struct InfoReplyRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1345 typedef InfoReplyRawT NativeTableType; 1346 typedef InfoReplyRawBuilder Builder; 1347 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1348 VT_COVER_FILTER = 4 1349 }; 1350 const ::flatbuffers::Vector<uint64_t> *cover_filter() const { 1351 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_COVER_FILTER); 1352 } 1353 bool Verify(::flatbuffers::Verifier &verifier) const { 1354 return VerifyTableStart(verifier) && 1355 VerifyOffset(verifier, VT_COVER_FILTER) && 1356 verifier.VerifyVector(cover_filter()) && 1357 verifier.EndTable(); 1358 } 1359 InfoReplyRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1360 void UnPackTo(InfoReplyRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1361 static ::flatbuffers::Offset<InfoReplyRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1362 }; 1363 1364 struct InfoReplyRawBuilder { 1365 typedef InfoReplyRaw Table; 1366 ::flatbuffers::FlatBufferBuilder &fbb_; 1367 ::flatbuffers::uoffset_t start_; 1368 void add_cover_filter(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> cover_filter) { 1369 fbb_.AddOffset(InfoReplyRaw::VT_COVER_FILTER, cover_filter); 1370 } 1371 explicit InfoReplyRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1372 : fbb_(_fbb) { 1373 start_ = fbb_.StartTable(); 1374 } 1375 ::flatbuffers::Offset<InfoReplyRaw> Finish() { 1376 const auto end = fbb_.EndTable(start_); 1377 auto o = ::flatbuffers::Offset<InfoReplyRaw>(end); 1378 return o; 1379 } 1380 }; 1381 1382 inline ::flatbuffers::Offset<InfoReplyRaw> CreateInfoReplyRaw( 1383 ::flatbuffers::FlatBufferBuilder &_fbb, 1384 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> cover_filter = 0) { 1385 InfoReplyRawBuilder builder_(_fbb); 1386 builder_.add_cover_filter(cover_filter); 1387 return builder_.Finish(); 1388 } 1389 1390 inline ::flatbuffers::Offset<InfoReplyRaw> CreateInfoReplyRawDirect( 1391 ::flatbuffers::FlatBufferBuilder &_fbb, 1392 const std::vector<uint64_t> *cover_filter = nullptr) { 1393 auto cover_filter__ = cover_filter ? _fbb.CreateVector<uint64_t>(*cover_filter) : 0; 1394 return rpc::CreateInfoReplyRaw( 1395 _fbb, 1396 cover_filter__); 1397 } 1398 1399 ::flatbuffers::Offset<InfoReplyRaw> CreateInfoReplyRaw(::flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1400 1401 struct FileInfoRawT : public ::flatbuffers::NativeTable { 1402 typedef FileInfoRaw TableType; 1403 std::string name{}; 1404 bool exists = false; 1405 std::string error{}; 1406 std::vector<uint8_t> data{}; 1407 }; 1408 1409 struct FileInfoRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1410 typedef FileInfoRawT NativeTableType; 1411 typedef FileInfoRawBuilder Builder; 1412 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1413 VT_NAME = 4, 1414 VT_EXISTS = 6, 1415 VT_ERROR = 8, 1416 VT_DATA = 10 1417 }; 1418 const ::flatbuffers::String *name() const { 1419 return GetPointer<const ::flatbuffers::String *>(VT_NAME); 1420 } 1421 bool exists() const { 1422 return GetField<uint8_t>(VT_EXISTS, 0) != 0; 1423 } 1424 const ::flatbuffers::String *error() const { 1425 return GetPointer<const ::flatbuffers::String *>(VT_ERROR); 1426 } 1427 const ::flatbuffers::Vector<uint8_t> *data() const { 1428 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA); 1429 } 1430 bool Verify(::flatbuffers::Verifier &verifier) const { 1431 return VerifyTableStart(verifier) && 1432 VerifyOffset(verifier, VT_NAME) && 1433 verifier.VerifyString(name()) && 1434 VerifyField<uint8_t>(verifier, VT_EXISTS, 1) && 1435 VerifyOffset(verifier, VT_ERROR) && 1436 verifier.VerifyString(error()) && 1437 VerifyOffset(verifier, VT_DATA) && 1438 verifier.VerifyVector(data()) && 1439 verifier.EndTable(); 1440 } 1441 FileInfoRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1442 void UnPackTo(FileInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1443 static ::flatbuffers::Offset<FileInfoRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FileInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1444 }; 1445 1446 struct FileInfoRawBuilder { 1447 typedef FileInfoRaw Table; 1448 ::flatbuffers::FlatBufferBuilder &fbb_; 1449 ::flatbuffers::uoffset_t start_; 1450 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) { 1451 fbb_.AddOffset(FileInfoRaw::VT_NAME, name); 1452 } 1453 void add_exists(bool exists) { 1454 fbb_.AddElement<uint8_t>(FileInfoRaw::VT_EXISTS, static_cast<uint8_t>(exists), 0); 1455 } 1456 void add_error(::flatbuffers::Offset<::flatbuffers::String> error) { 1457 fbb_.AddOffset(FileInfoRaw::VT_ERROR, error); 1458 } 1459 void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) { 1460 fbb_.AddOffset(FileInfoRaw::VT_DATA, data); 1461 } 1462 explicit FileInfoRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1463 : fbb_(_fbb) { 1464 start_ = fbb_.StartTable(); 1465 } 1466 ::flatbuffers::Offset<FileInfoRaw> Finish() { 1467 const auto end = fbb_.EndTable(start_); 1468 auto o = ::flatbuffers::Offset<FileInfoRaw>(end); 1469 return o; 1470 } 1471 }; 1472 1473 inline ::flatbuffers::Offset<FileInfoRaw> CreateFileInfoRaw( 1474 ::flatbuffers::FlatBufferBuilder &_fbb, 1475 ::flatbuffers::Offset<::flatbuffers::String> name = 0, 1476 bool exists = false, 1477 ::flatbuffers::Offset<::flatbuffers::String> error = 0, 1478 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) { 1479 FileInfoRawBuilder builder_(_fbb); 1480 builder_.add_data(data); 1481 builder_.add_error(error); 1482 builder_.add_name(name); 1483 builder_.add_exists(exists); 1484 return builder_.Finish(); 1485 } 1486 1487 inline ::flatbuffers::Offset<FileInfoRaw> CreateFileInfoRawDirect( 1488 ::flatbuffers::FlatBufferBuilder &_fbb, 1489 const char *name = nullptr, 1490 bool exists = false, 1491 const char *error = nullptr, 1492 const std::vector<uint8_t> *data = nullptr) { 1493 auto name__ = name ? _fbb.CreateString(name) : 0; 1494 auto error__ = error ? _fbb.CreateString(error) : 0; 1495 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0; 1496 return rpc::CreateFileInfoRaw( 1497 _fbb, 1498 name__, 1499 exists, 1500 error__, 1501 data__); 1502 } 1503 1504 ::flatbuffers::Offset<FileInfoRaw> CreateFileInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const FileInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1505 1506 struct GlobInfoRawT : public ::flatbuffers::NativeTable { 1507 typedef GlobInfoRaw TableType; 1508 std::string name{}; 1509 std::vector<std::string> files{}; 1510 }; 1511 1512 struct GlobInfoRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1513 typedef GlobInfoRawT NativeTableType; 1514 typedef GlobInfoRawBuilder Builder; 1515 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1516 VT_NAME = 4, 1517 VT_FILES = 6 1518 }; 1519 const ::flatbuffers::String *name() const { 1520 return GetPointer<const ::flatbuffers::String *>(VT_NAME); 1521 } 1522 const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *files() const { 1523 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>> *>(VT_FILES); 1524 } 1525 bool Verify(::flatbuffers::Verifier &verifier) const { 1526 return VerifyTableStart(verifier) && 1527 VerifyOffset(verifier, VT_NAME) && 1528 verifier.VerifyString(name()) && 1529 VerifyOffset(verifier, VT_FILES) && 1530 verifier.VerifyVector(files()) && 1531 verifier.VerifyVectorOfStrings(files()) && 1532 verifier.EndTable(); 1533 } 1534 GlobInfoRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1535 void UnPackTo(GlobInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1536 static ::flatbuffers::Offset<GlobInfoRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1537 }; 1538 1539 struct GlobInfoRawBuilder { 1540 typedef GlobInfoRaw Table; 1541 ::flatbuffers::FlatBufferBuilder &fbb_; 1542 ::flatbuffers::uoffset_t start_; 1543 void add_name(::flatbuffers::Offset<::flatbuffers::String> name) { 1544 fbb_.AddOffset(GlobInfoRaw::VT_NAME, name); 1545 } 1546 void add_files(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> files) { 1547 fbb_.AddOffset(GlobInfoRaw::VT_FILES, files); 1548 } 1549 explicit GlobInfoRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1550 : fbb_(_fbb) { 1551 start_ = fbb_.StartTable(); 1552 } 1553 ::flatbuffers::Offset<GlobInfoRaw> Finish() { 1554 const auto end = fbb_.EndTable(start_); 1555 auto o = ::flatbuffers::Offset<GlobInfoRaw>(end); 1556 return o; 1557 } 1558 }; 1559 1560 inline ::flatbuffers::Offset<GlobInfoRaw> CreateGlobInfoRaw( 1561 ::flatbuffers::FlatBufferBuilder &_fbb, 1562 ::flatbuffers::Offset<::flatbuffers::String> name = 0, 1563 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<::flatbuffers::String>>> files = 0) { 1564 GlobInfoRawBuilder builder_(_fbb); 1565 builder_.add_files(files); 1566 builder_.add_name(name); 1567 return builder_.Finish(); 1568 } 1569 1570 inline ::flatbuffers::Offset<GlobInfoRaw> CreateGlobInfoRawDirect( 1571 ::flatbuffers::FlatBufferBuilder &_fbb, 1572 const char *name = nullptr, 1573 const std::vector<::flatbuffers::Offset<::flatbuffers::String>> *files = nullptr) { 1574 auto name__ = name ? _fbb.CreateString(name) : 0; 1575 auto files__ = files ? _fbb.CreateVector<::flatbuffers::Offset<::flatbuffers::String>>(*files) : 0; 1576 return rpc::CreateGlobInfoRaw( 1577 _fbb, 1578 name__, 1579 files__); 1580 } 1581 1582 ::flatbuffers::Offset<GlobInfoRaw> CreateGlobInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1583 1584 struct FeatureInfoRawT : public ::flatbuffers::NativeTable { 1585 typedef FeatureInfoRaw TableType; 1586 rpc::Feature id = static_cast<rpc::Feature>(0); 1587 bool need_setup = false; 1588 std::string reason{}; 1589 }; 1590 1591 struct FeatureInfoRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1592 typedef FeatureInfoRawT NativeTableType; 1593 typedef FeatureInfoRawBuilder Builder; 1594 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1595 VT_ID = 4, 1596 VT_NEED_SETUP = 6, 1597 VT_REASON = 8 1598 }; 1599 rpc::Feature id() const { 1600 return static_cast<rpc::Feature>(GetField<uint64_t>(VT_ID, 0)); 1601 } 1602 bool need_setup() const { 1603 return GetField<uint8_t>(VT_NEED_SETUP, 0) != 0; 1604 } 1605 const ::flatbuffers::String *reason() const { 1606 return GetPointer<const ::flatbuffers::String *>(VT_REASON); 1607 } 1608 bool Verify(::flatbuffers::Verifier &verifier) const { 1609 return VerifyTableStart(verifier) && 1610 VerifyField<uint64_t>(verifier, VT_ID, 8) && 1611 VerifyField<uint8_t>(verifier, VT_NEED_SETUP, 1) && 1612 VerifyOffset(verifier, VT_REASON) && 1613 verifier.VerifyString(reason()) && 1614 verifier.EndTable(); 1615 } 1616 FeatureInfoRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1617 void UnPackTo(FeatureInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1618 static ::flatbuffers::Offset<FeatureInfoRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FeatureInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1619 }; 1620 1621 struct FeatureInfoRawBuilder { 1622 typedef FeatureInfoRaw Table; 1623 ::flatbuffers::FlatBufferBuilder &fbb_; 1624 ::flatbuffers::uoffset_t start_; 1625 void add_id(rpc::Feature id) { 1626 fbb_.AddElement<uint64_t>(FeatureInfoRaw::VT_ID, static_cast<uint64_t>(id), 0); 1627 } 1628 void add_need_setup(bool need_setup) { 1629 fbb_.AddElement<uint8_t>(FeatureInfoRaw::VT_NEED_SETUP, static_cast<uint8_t>(need_setup), 0); 1630 } 1631 void add_reason(::flatbuffers::Offset<::flatbuffers::String> reason) { 1632 fbb_.AddOffset(FeatureInfoRaw::VT_REASON, reason); 1633 } 1634 explicit FeatureInfoRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1635 : fbb_(_fbb) { 1636 start_ = fbb_.StartTable(); 1637 } 1638 ::flatbuffers::Offset<FeatureInfoRaw> Finish() { 1639 const auto end = fbb_.EndTable(start_); 1640 auto o = ::flatbuffers::Offset<FeatureInfoRaw>(end); 1641 return o; 1642 } 1643 }; 1644 1645 inline ::flatbuffers::Offset<FeatureInfoRaw> CreateFeatureInfoRaw( 1646 ::flatbuffers::FlatBufferBuilder &_fbb, 1647 rpc::Feature id = static_cast<rpc::Feature>(0), 1648 bool need_setup = false, 1649 ::flatbuffers::Offset<::flatbuffers::String> reason = 0) { 1650 FeatureInfoRawBuilder builder_(_fbb); 1651 builder_.add_id(id); 1652 builder_.add_reason(reason); 1653 builder_.add_need_setup(need_setup); 1654 return builder_.Finish(); 1655 } 1656 1657 inline ::flatbuffers::Offset<FeatureInfoRaw> CreateFeatureInfoRawDirect( 1658 ::flatbuffers::FlatBufferBuilder &_fbb, 1659 rpc::Feature id = static_cast<rpc::Feature>(0), 1660 bool need_setup = false, 1661 const char *reason = nullptr) { 1662 auto reason__ = reason ? _fbb.CreateString(reason) : 0; 1663 return rpc::CreateFeatureInfoRaw( 1664 _fbb, 1665 id, 1666 need_setup, 1667 reason__); 1668 } 1669 1670 ::flatbuffers::Offset<FeatureInfoRaw> CreateFeatureInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const FeatureInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1671 1672 struct HostMessageRawT : public ::flatbuffers::NativeTable { 1673 typedef HostMessageRaw TableType; 1674 rpc::HostMessagesRawUnion msg{}; 1675 }; 1676 1677 struct HostMessageRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1678 typedef HostMessageRawT NativeTableType; 1679 typedef HostMessageRawBuilder Builder; 1680 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1681 VT_MSG_TYPE = 4, 1682 VT_MSG = 6 1683 }; 1684 rpc::HostMessagesRaw msg_type() const { 1685 return static_cast<rpc::HostMessagesRaw>(GetField<uint8_t>(VT_MSG_TYPE, 0)); 1686 } 1687 const void *msg() const { 1688 return GetPointer<const void *>(VT_MSG); 1689 } 1690 template<typename T> const T *msg_as() const; 1691 const rpc::ExecRequestRaw *msg_as_ExecRequest() const { 1692 return msg_type() == rpc::HostMessagesRaw::ExecRequest ? static_cast<const rpc::ExecRequestRaw *>(msg()) : nullptr; 1693 } 1694 const rpc::SignalUpdateRaw *msg_as_SignalUpdate() const { 1695 return msg_type() == rpc::HostMessagesRaw::SignalUpdate ? static_cast<const rpc::SignalUpdateRaw *>(msg()) : nullptr; 1696 } 1697 const rpc::CorpusTriagedRaw *msg_as_CorpusTriaged() const { 1698 return msg_type() == rpc::HostMessagesRaw::CorpusTriaged ? static_cast<const rpc::CorpusTriagedRaw *>(msg()) : nullptr; 1699 } 1700 const rpc::StateRequestRaw *msg_as_StateRequest() const { 1701 return msg_type() == rpc::HostMessagesRaw::StateRequest ? static_cast<const rpc::StateRequestRaw *>(msg()) : nullptr; 1702 } 1703 bool Verify(::flatbuffers::Verifier &verifier) const { 1704 return VerifyTableStart(verifier) && 1705 VerifyField<uint8_t>(verifier, VT_MSG_TYPE, 1) && 1706 VerifyOffset(verifier, VT_MSG) && 1707 VerifyHostMessagesRaw(verifier, msg(), msg_type()) && 1708 verifier.EndTable(); 1709 } 1710 HostMessageRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1711 void UnPackTo(HostMessageRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1712 static ::flatbuffers::Offset<HostMessageRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HostMessageRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1713 }; 1714 1715 template<> inline const rpc::ExecRequestRaw *HostMessageRaw::msg_as<rpc::ExecRequestRaw>() const { 1716 return msg_as_ExecRequest(); 1717 } 1718 1719 template<> inline const rpc::SignalUpdateRaw *HostMessageRaw::msg_as<rpc::SignalUpdateRaw>() const { 1720 return msg_as_SignalUpdate(); 1721 } 1722 1723 template<> inline const rpc::CorpusTriagedRaw *HostMessageRaw::msg_as<rpc::CorpusTriagedRaw>() const { 1724 return msg_as_CorpusTriaged(); 1725 } 1726 1727 template<> inline const rpc::StateRequestRaw *HostMessageRaw::msg_as<rpc::StateRequestRaw>() const { 1728 return msg_as_StateRequest(); 1729 } 1730 1731 struct HostMessageRawBuilder { 1732 typedef HostMessageRaw Table; 1733 ::flatbuffers::FlatBufferBuilder &fbb_; 1734 ::flatbuffers::uoffset_t start_; 1735 void add_msg_type(rpc::HostMessagesRaw msg_type) { 1736 fbb_.AddElement<uint8_t>(HostMessageRaw::VT_MSG_TYPE, static_cast<uint8_t>(msg_type), 0); 1737 } 1738 void add_msg(::flatbuffers::Offset<void> msg) { 1739 fbb_.AddOffset(HostMessageRaw::VT_MSG, msg); 1740 } 1741 explicit HostMessageRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1742 : fbb_(_fbb) { 1743 start_ = fbb_.StartTable(); 1744 } 1745 ::flatbuffers::Offset<HostMessageRaw> Finish() { 1746 const auto end = fbb_.EndTable(start_); 1747 auto o = ::flatbuffers::Offset<HostMessageRaw>(end); 1748 return o; 1749 } 1750 }; 1751 1752 inline ::flatbuffers::Offset<HostMessageRaw> CreateHostMessageRaw( 1753 ::flatbuffers::FlatBufferBuilder &_fbb, 1754 rpc::HostMessagesRaw msg_type = rpc::HostMessagesRaw::NONE, 1755 ::flatbuffers::Offset<void> msg = 0) { 1756 HostMessageRawBuilder builder_(_fbb); 1757 builder_.add_msg(msg); 1758 builder_.add_msg_type(msg_type); 1759 return builder_.Finish(); 1760 } 1761 1762 ::flatbuffers::Offset<HostMessageRaw> CreateHostMessageRaw(::flatbuffers::FlatBufferBuilder &_fbb, const HostMessageRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1763 1764 struct ExecutorMessageRawT : public ::flatbuffers::NativeTable { 1765 typedef ExecutorMessageRaw TableType; 1766 rpc::ExecutorMessagesRawUnion msg{}; 1767 }; 1768 1769 struct ExecutorMessageRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1770 typedef ExecutorMessageRawT NativeTableType; 1771 typedef ExecutorMessageRawBuilder Builder; 1772 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1773 VT_MSG_TYPE = 4, 1774 VT_MSG = 6 1775 }; 1776 rpc::ExecutorMessagesRaw msg_type() const { 1777 return static_cast<rpc::ExecutorMessagesRaw>(GetField<uint8_t>(VT_MSG_TYPE, 0)); 1778 } 1779 const void *msg() const { 1780 return GetPointer<const void *>(VT_MSG); 1781 } 1782 template<typename T> const T *msg_as() const; 1783 const rpc::ExecResultRaw *msg_as_ExecResult() const { 1784 return msg_type() == rpc::ExecutorMessagesRaw::ExecResult ? static_cast<const rpc::ExecResultRaw *>(msg()) : nullptr; 1785 } 1786 const rpc::ExecutingMessageRaw *msg_as_Executing() const { 1787 return msg_type() == rpc::ExecutorMessagesRaw::Executing ? static_cast<const rpc::ExecutingMessageRaw *>(msg()) : nullptr; 1788 } 1789 const rpc::StateResultRaw *msg_as_State() const { 1790 return msg_type() == rpc::ExecutorMessagesRaw::State ? static_cast<const rpc::StateResultRaw *>(msg()) : nullptr; 1791 } 1792 bool Verify(::flatbuffers::Verifier &verifier) const { 1793 return VerifyTableStart(verifier) && 1794 VerifyField<uint8_t>(verifier, VT_MSG_TYPE, 1) && 1795 VerifyOffset(verifier, VT_MSG) && 1796 VerifyExecutorMessagesRaw(verifier, msg(), msg_type()) && 1797 verifier.EndTable(); 1798 } 1799 ExecutorMessageRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1800 void UnPackTo(ExecutorMessageRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1801 static ::flatbuffers::Offset<ExecutorMessageRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1802 }; 1803 1804 template<> inline const rpc::ExecResultRaw *ExecutorMessageRaw::msg_as<rpc::ExecResultRaw>() const { 1805 return msg_as_ExecResult(); 1806 } 1807 1808 template<> inline const rpc::ExecutingMessageRaw *ExecutorMessageRaw::msg_as<rpc::ExecutingMessageRaw>() const { 1809 return msg_as_Executing(); 1810 } 1811 1812 template<> inline const rpc::StateResultRaw *ExecutorMessageRaw::msg_as<rpc::StateResultRaw>() const { 1813 return msg_as_State(); 1814 } 1815 1816 struct ExecutorMessageRawBuilder { 1817 typedef ExecutorMessageRaw Table; 1818 ::flatbuffers::FlatBufferBuilder &fbb_; 1819 ::flatbuffers::uoffset_t start_; 1820 void add_msg_type(rpc::ExecutorMessagesRaw msg_type) { 1821 fbb_.AddElement<uint8_t>(ExecutorMessageRaw::VT_MSG_TYPE, static_cast<uint8_t>(msg_type), 0); 1822 } 1823 void add_msg(::flatbuffers::Offset<void> msg) { 1824 fbb_.AddOffset(ExecutorMessageRaw::VT_MSG, msg); 1825 } 1826 explicit ExecutorMessageRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1827 : fbb_(_fbb) { 1828 start_ = fbb_.StartTable(); 1829 } 1830 ::flatbuffers::Offset<ExecutorMessageRaw> Finish() { 1831 const auto end = fbb_.EndTable(start_); 1832 auto o = ::flatbuffers::Offset<ExecutorMessageRaw>(end); 1833 return o; 1834 } 1835 }; 1836 1837 inline ::flatbuffers::Offset<ExecutorMessageRaw> CreateExecutorMessageRaw( 1838 ::flatbuffers::FlatBufferBuilder &_fbb, 1839 rpc::ExecutorMessagesRaw msg_type = rpc::ExecutorMessagesRaw::NONE, 1840 ::flatbuffers::Offset<void> msg = 0) { 1841 ExecutorMessageRawBuilder builder_(_fbb); 1842 builder_.add_msg(msg); 1843 builder_.add_msg_type(msg_type); 1844 return builder_.Finish(); 1845 } 1846 1847 ::flatbuffers::Offset<ExecutorMessageRaw> CreateExecutorMessageRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1848 1849 struct ExecRequestRawT : public ::flatbuffers::NativeTable { 1850 typedef ExecRequestRaw TableType; 1851 int64_t id = 0; 1852 rpc::RequestType type = rpc::RequestType::Program; 1853 uint64_t avoid = 0; 1854 std::vector<uint8_t> data{}; 1855 std::unique_ptr<rpc::ExecOptsRaw> exec_opts{}; 1856 rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0); 1857 std::vector<int32_t> all_signal{}; 1858 ExecRequestRawT() = default; 1859 ExecRequestRawT(const ExecRequestRawT &o); 1860 ExecRequestRawT(ExecRequestRawT&&) FLATBUFFERS_NOEXCEPT = default; 1861 ExecRequestRawT &operator=(ExecRequestRawT o) FLATBUFFERS_NOEXCEPT; 1862 }; 1863 1864 struct ExecRequestRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 1865 typedef ExecRequestRawT NativeTableType; 1866 typedef ExecRequestRawBuilder Builder; 1867 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 1868 VT_ID = 4, 1869 VT_TYPE = 6, 1870 VT_AVOID = 8, 1871 VT_DATA = 10, 1872 VT_EXEC_OPTS = 12, 1873 VT_FLAGS = 14, 1874 VT_ALL_SIGNAL = 16 1875 }; 1876 int64_t id() const { 1877 return GetField<int64_t>(VT_ID, 0); 1878 } 1879 rpc::RequestType type() const { 1880 return static_cast<rpc::RequestType>(GetField<uint64_t>(VT_TYPE, 0)); 1881 } 1882 uint64_t avoid() const { 1883 return GetField<uint64_t>(VT_AVOID, 0); 1884 } 1885 const ::flatbuffers::Vector<uint8_t> *data() const { 1886 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA); 1887 } 1888 const rpc::ExecOptsRaw *exec_opts() const { 1889 return GetStruct<const rpc::ExecOptsRaw *>(VT_EXEC_OPTS); 1890 } 1891 rpc::RequestFlag flags() const { 1892 return static_cast<rpc::RequestFlag>(GetField<uint64_t>(VT_FLAGS, 0)); 1893 } 1894 const ::flatbuffers::Vector<int32_t> *all_signal() const { 1895 return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_ALL_SIGNAL); 1896 } 1897 bool Verify(::flatbuffers::Verifier &verifier) const { 1898 return VerifyTableStart(verifier) && 1899 VerifyField<int64_t>(verifier, VT_ID, 8) && 1900 VerifyField<uint64_t>(verifier, VT_TYPE, 8) && 1901 VerifyField<uint64_t>(verifier, VT_AVOID, 8) && 1902 VerifyOffset(verifier, VT_DATA) && 1903 verifier.VerifyVector(data()) && 1904 VerifyField<rpc::ExecOptsRaw>(verifier, VT_EXEC_OPTS, 8) && 1905 VerifyField<uint64_t>(verifier, VT_FLAGS, 8) && 1906 VerifyOffset(verifier, VT_ALL_SIGNAL) && 1907 verifier.VerifyVector(all_signal()) && 1908 verifier.EndTable(); 1909 } 1910 ExecRequestRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1911 void UnPackTo(ExecRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 1912 static ::flatbuffers::Offset<ExecRequestRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1913 }; 1914 1915 struct ExecRequestRawBuilder { 1916 typedef ExecRequestRaw Table; 1917 ::flatbuffers::FlatBufferBuilder &fbb_; 1918 ::flatbuffers::uoffset_t start_; 1919 void add_id(int64_t id) { 1920 fbb_.AddElement<int64_t>(ExecRequestRaw::VT_ID, id, 0); 1921 } 1922 void add_type(rpc::RequestType type) { 1923 fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_TYPE, static_cast<uint64_t>(type), 0); 1924 } 1925 void add_avoid(uint64_t avoid) { 1926 fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_AVOID, avoid, 0); 1927 } 1928 void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) { 1929 fbb_.AddOffset(ExecRequestRaw::VT_DATA, data); 1930 } 1931 void add_exec_opts(const rpc::ExecOptsRaw *exec_opts) { 1932 fbb_.AddStruct(ExecRequestRaw::VT_EXEC_OPTS, exec_opts); 1933 } 1934 void add_flags(rpc::RequestFlag flags) { 1935 fbb_.AddElement<uint64_t>(ExecRequestRaw::VT_FLAGS, static_cast<uint64_t>(flags), 0); 1936 } 1937 void add_all_signal(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> all_signal) { 1938 fbb_.AddOffset(ExecRequestRaw::VT_ALL_SIGNAL, all_signal); 1939 } 1940 explicit ExecRequestRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 1941 : fbb_(_fbb) { 1942 start_ = fbb_.StartTable(); 1943 } 1944 ::flatbuffers::Offset<ExecRequestRaw> Finish() { 1945 const auto end = fbb_.EndTable(start_); 1946 auto o = ::flatbuffers::Offset<ExecRequestRaw>(end); 1947 return o; 1948 } 1949 }; 1950 1951 inline ::flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw( 1952 ::flatbuffers::FlatBufferBuilder &_fbb, 1953 int64_t id = 0, 1954 rpc::RequestType type = rpc::RequestType::Program, 1955 uint64_t avoid = 0, 1956 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0, 1957 const rpc::ExecOptsRaw *exec_opts = nullptr, 1958 rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0), 1959 ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> all_signal = 0) { 1960 ExecRequestRawBuilder builder_(_fbb); 1961 builder_.add_flags(flags); 1962 builder_.add_avoid(avoid); 1963 builder_.add_type(type); 1964 builder_.add_id(id); 1965 builder_.add_all_signal(all_signal); 1966 builder_.add_exec_opts(exec_opts); 1967 builder_.add_data(data); 1968 return builder_.Finish(); 1969 } 1970 1971 inline ::flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRawDirect( 1972 ::flatbuffers::FlatBufferBuilder &_fbb, 1973 int64_t id = 0, 1974 rpc::RequestType type = rpc::RequestType::Program, 1975 uint64_t avoid = 0, 1976 const std::vector<uint8_t> *data = nullptr, 1977 const rpc::ExecOptsRaw *exec_opts = nullptr, 1978 rpc::RequestFlag flags = static_cast<rpc::RequestFlag>(0), 1979 const std::vector<int32_t> *all_signal = nullptr) { 1980 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0; 1981 auto all_signal__ = all_signal ? _fbb.CreateVector<int32_t>(*all_signal) : 0; 1982 return rpc::CreateExecRequestRaw( 1983 _fbb, 1984 id, 1985 type, 1986 avoid, 1987 data__, 1988 exec_opts, 1989 flags, 1990 all_signal__); 1991 } 1992 1993 ::flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 1994 1995 struct SignalUpdateRawT : public ::flatbuffers::NativeTable { 1996 typedef SignalUpdateRaw TableType; 1997 std::vector<uint64_t> new_max{}; 1998 }; 1999 2000 struct SignalUpdateRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2001 typedef SignalUpdateRawT NativeTableType; 2002 typedef SignalUpdateRawBuilder Builder; 2003 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2004 VT_NEW_MAX = 4 2005 }; 2006 const ::flatbuffers::Vector<uint64_t> *new_max() const { 2007 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_NEW_MAX); 2008 } 2009 bool Verify(::flatbuffers::Verifier &verifier) const { 2010 return VerifyTableStart(verifier) && 2011 VerifyOffset(verifier, VT_NEW_MAX) && 2012 verifier.VerifyVector(new_max()) && 2013 verifier.EndTable(); 2014 } 2015 SignalUpdateRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2016 void UnPackTo(SignalUpdateRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2017 static ::flatbuffers::Offset<SignalUpdateRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2018 }; 2019 2020 struct SignalUpdateRawBuilder { 2021 typedef SignalUpdateRaw Table; 2022 ::flatbuffers::FlatBufferBuilder &fbb_; 2023 ::flatbuffers::uoffset_t start_; 2024 void add_new_max(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> new_max) { 2025 fbb_.AddOffset(SignalUpdateRaw::VT_NEW_MAX, new_max); 2026 } 2027 explicit SignalUpdateRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2028 : fbb_(_fbb) { 2029 start_ = fbb_.StartTable(); 2030 } 2031 ::flatbuffers::Offset<SignalUpdateRaw> Finish() { 2032 const auto end = fbb_.EndTable(start_); 2033 auto o = ::flatbuffers::Offset<SignalUpdateRaw>(end); 2034 return o; 2035 } 2036 }; 2037 2038 inline ::flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw( 2039 ::flatbuffers::FlatBufferBuilder &_fbb, 2040 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> new_max = 0) { 2041 SignalUpdateRawBuilder builder_(_fbb); 2042 builder_.add_new_max(new_max); 2043 return builder_.Finish(); 2044 } 2045 2046 inline ::flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRawDirect( 2047 ::flatbuffers::FlatBufferBuilder &_fbb, 2048 const std::vector<uint64_t> *new_max = nullptr) { 2049 auto new_max__ = new_max ? _fbb.CreateVector<uint64_t>(*new_max) : 0; 2050 return rpc::CreateSignalUpdateRaw( 2051 _fbb, 2052 new_max__); 2053 } 2054 2055 ::flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw(::flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2056 2057 struct CorpusTriagedRawT : public ::flatbuffers::NativeTable { 2058 typedef CorpusTriagedRaw TableType; 2059 }; 2060 2061 struct CorpusTriagedRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2062 typedef CorpusTriagedRawT NativeTableType; 2063 typedef CorpusTriagedRawBuilder Builder; 2064 bool Verify(::flatbuffers::Verifier &verifier) const { 2065 return VerifyTableStart(verifier) && 2066 verifier.EndTable(); 2067 } 2068 CorpusTriagedRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2069 void UnPackTo(CorpusTriagedRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2070 static ::flatbuffers::Offset<CorpusTriagedRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2071 }; 2072 2073 struct CorpusTriagedRawBuilder { 2074 typedef CorpusTriagedRaw Table; 2075 ::flatbuffers::FlatBufferBuilder &fbb_; 2076 ::flatbuffers::uoffset_t start_; 2077 explicit CorpusTriagedRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2078 : fbb_(_fbb) { 2079 start_ = fbb_.StartTable(); 2080 } 2081 ::flatbuffers::Offset<CorpusTriagedRaw> Finish() { 2082 const auto end = fbb_.EndTable(start_); 2083 auto o = ::flatbuffers::Offset<CorpusTriagedRaw>(end); 2084 return o; 2085 } 2086 }; 2087 2088 inline ::flatbuffers::Offset<CorpusTriagedRaw> CreateCorpusTriagedRaw( 2089 ::flatbuffers::FlatBufferBuilder &_fbb) { 2090 CorpusTriagedRawBuilder builder_(_fbb); 2091 return builder_.Finish(); 2092 } 2093 2094 ::flatbuffers::Offset<CorpusTriagedRaw> CreateCorpusTriagedRaw(::flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2095 2096 struct StateRequestRawT : public ::flatbuffers::NativeTable { 2097 typedef StateRequestRaw TableType; 2098 }; 2099 2100 struct StateRequestRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2101 typedef StateRequestRawT NativeTableType; 2102 typedef StateRequestRawBuilder Builder; 2103 bool Verify(::flatbuffers::Verifier &verifier) const { 2104 return VerifyTableStart(verifier) && 2105 verifier.EndTable(); 2106 } 2107 StateRequestRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2108 void UnPackTo(StateRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2109 static ::flatbuffers::Offset<StateRequestRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2110 }; 2111 2112 struct StateRequestRawBuilder { 2113 typedef StateRequestRaw Table; 2114 ::flatbuffers::FlatBufferBuilder &fbb_; 2115 ::flatbuffers::uoffset_t start_; 2116 explicit StateRequestRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2117 : fbb_(_fbb) { 2118 start_ = fbb_.StartTable(); 2119 } 2120 ::flatbuffers::Offset<StateRequestRaw> Finish() { 2121 const auto end = fbb_.EndTable(start_); 2122 auto o = ::flatbuffers::Offset<StateRequestRaw>(end); 2123 return o; 2124 } 2125 }; 2126 2127 inline ::flatbuffers::Offset<StateRequestRaw> CreateStateRequestRaw( 2128 ::flatbuffers::FlatBufferBuilder &_fbb) { 2129 StateRequestRawBuilder builder_(_fbb); 2130 return builder_.Finish(); 2131 } 2132 2133 ::flatbuffers::Offset<StateRequestRaw> CreateStateRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2134 2135 struct ExecutingMessageRawT : public ::flatbuffers::NativeTable { 2136 typedef ExecutingMessageRaw TableType; 2137 int64_t id = 0; 2138 int32_t proc_id = 0; 2139 int32_t try_ = 0; 2140 int64_t wait_duration = 0; 2141 }; 2142 2143 struct ExecutingMessageRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2144 typedef ExecutingMessageRawT NativeTableType; 2145 typedef ExecutingMessageRawBuilder Builder; 2146 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2147 VT_ID = 4, 2148 VT_PROC_ID = 6, 2149 VT_TRY_ = 8, 2150 VT_WAIT_DURATION = 10 2151 }; 2152 int64_t id() const { 2153 return GetField<int64_t>(VT_ID, 0); 2154 } 2155 int32_t proc_id() const { 2156 return GetField<int32_t>(VT_PROC_ID, 0); 2157 } 2158 int32_t try_() const { 2159 return GetField<int32_t>(VT_TRY_, 0); 2160 } 2161 int64_t wait_duration() const { 2162 return GetField<int64_t>(VT_WAIT_DURATION, 0); 2163 } 2164 bool Verify(::flatbuffers::Verifier &verifier) const { 2165 return VerifyTableStart(verifier) && 2166 VerifyField<int64_t>(verifier, VT_ID, 8) && 2167 VerifyField<int32_t>(verifier, VT_PROC_ID, 4) && 2168 VerifyField<int32_t>(verifier, VT_TRY_, 4) && 2169 VerifyField<int64_t>(verifier, VT_WAIT_DURATION, 8) && 2170 verifier.EndTable(); 2171 } 2172 ExecutingMessageRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2173 void UnPackTo(ExecutingMessageRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2174 static ::flatbuffers::Offset<ExecutingMessageRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2175 }; 2176 2177 struct ExecutingMessageRawBuilder { 2178 typedef ExecutingMessageRaw Table; 2179 ::flatbuffers::FlatBufferBuilder &fbb_; 2180 ::flatbuffers::uoffset_t start_; 2181 void add_id(int64_t id) { 2182 fbb_.AddElement<int64_t>(ExecutingMessageRaw::VT_ID, id, 0); 2183 } 2184 void add_proc_id(int32_t proc_id) { 2185 fbb_.AddElement<int32_t>(ExecutingMessageRaw::VT_PROC_ID, proc_id, 0); 2186 } 2187 void add_try_(int32_t try_) { 2188 fbb_.AddElement<int32_t>(ExecutingMessageRaw::VT_TRY_, try_, 0); 2189 } 2190 void add_wait_duration(int64_t wait_duration) { 2191 fbb_.AddElement<int64_t>(ExecutingMessageRaw::VT_WAIT_DURATION, wait_duration, 0); 2192 } 2193 explicit ExecutingMessageRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2194 : fbb_(_fbb) { 2195 start_ = fbb_.StartTable(); 2196 } 2197 ::flatbuffers::Offset<ExecutingMessageRaw> Finish() { 2198 const auto end = fbb_.EndTable(start_); 2199 auto o = ::flatbuffers::Offset<ExecutingMessageRaw>(end); 2200 return o; 2201 } 2202 }; 2203 2204 inline ::flatbuffers::Offset<ExecutingMessageRaw> CreateExecutingMessageRaw( 2205 ::flatbuffers::FlatBufferBuilder &_fbb, 2206 int64_t id = 0, 2207 int32_t proc_id = 0, 2208 int32_t try_ = 0, 2209 int64_t wait_duration = 0) { 2210 ExecutingMessageRawBuilder builder_(_fbb); 2211 builder_.add_wait_duration(wait_duration); 2212 builder_.add_id(id); 2213 builder_.add_try_(try_); 2214 builder_.add_proc_id(proc_id); 2215 return builder_.Finish(); 2216 } 2217 2218 ::flatbuffers::Offset<ExecutingMessageRaw> CreateExecutingMessageRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2219 2220 struct CallInfoRawT : public ::flatbuffers::NativeTable { 2221 typedef CallInfoRaw TableType; 2222 rpc::CallFlag flags = static_cast<rpc::CallFlag>(0); 2223 int32_t error = 0; 2224 std::vector<uint64_t> signal{}; 2225 std::vector<uint64_t> cover{}; 2226 std::vector<rpc::ComparisonRaw> comps{}; 2227 }; 2228 2229 struct CallInfoRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2230 typedef CallInfoRawT NativeTableType; 2231 typedef CallInfoRawBuilder Builder; 2232 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2233 VT_FLAGS = 4, 2234 VT_ERROR = 6, 2235 VT_SIGNAL = 8, 2236 VT_COVER = 10, 2237 VT_COMPS = 12 2238 }; 2239 rpc::CallFlag flags() const { 2240 return static_cast<rpc::CallFlag>(GetField<uint8_t>(VT_FLAGS, 0)); 2241 } 2242 int32_t error() const { 2243 return GetField<int32_t>(VT_ERROR, 0); 2244 } 2245 const ::flatbuffers::Vector<uint64_t> *signal() const { 2246 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_SIGNAL); 2247 } 2248 const ::flatbuffers::Vector<uint64_t> *cover() const { 2249 return GetPointer<const ::flatbuffers::Vector<uint64_t> *>(VT_COVER); 2250 } 2251 const ::flatbuffers::Vector<const rpc::ComparisonRaw *> *comps() const { 2252 return GetPointer<const ::flatbuffers::Vector<const rpc::ComparisonRaw *> *>(VT_COMPS); 2253 } 2254 bool Verify(::flatbuffers::Verifier &verifier) const { 2255 return VerifyTableStart(verifier) && 2256 VerifyField<uint8_t>(verifier, VT_FLAGS, 1) && 2257 VerifyField<int32_t>(verifier, VT_ERROR, 4) && 2258 VerifyOffset(verifier, VT_SIGNAL) && 2259 verifier.VerifyVector(signal()) && 2260 VerifyOffset(verifier, VT_COVER) && 2261 verifier.VerifyVector(cover()) && 2262 VerifyOffset(verifier, VT_COMPS) && 2263 verifier.VerifyVector(comps()) && 2264 verifier.EndTable(); 2265 } 2266 CallInfoRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2267 void UnPackTo(CallInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2268 static ::flatbuffers::Offset<CallInfoRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2269 }; 2270 2271 struct CallInfoRawBuilder { 2272 typedef CallInfoRaw Table; 2273 ::flatbuffers::FlatBufferBuilder &fbb_; 2274 ::flatbuffers::uoffset_t start_; 2275 void add_flags(rpc::CallFlag flags) { 2276 fbb_.AddElement<uint8_t>(CallInfoRaw::VT_FLAGS, static_cast<uint8_t>(flags), 0); 2277 } 2278 void add_error(int32_t error) { 2279 fbb_.AddElement<int32_t>(CallInfoRaw::VT_ERROR, error, 0); 2280 } 2281 void add_signal(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> signal) { 2282 fbb_.AddOffset(CallInfoRaw::VT_SIGNAL, signal); 2283 } 2284 void add_cover(::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> cover) { 2285 fbb_.AddOffset(CallInfoRaw::VT_COVER, cover); 2286 } 2287 void add_comps(::flatbuffers::Offset<::flatbuffers::Vector<const rpc::ComparisonRaw *>> comps) { 2288 fbb_.AddOffset(CallInfoRaw::VT_COMPS, comps); 2289 } 2290 explicit CallInfoRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2291 : fbb_(_fbb) { 2292 start_ = fbb_.StartTable(); 2293 } 2294 ::flatbuffers::Offset<CallInfoRaw> Finish() { 2295 const auto end = fbb_.EndTable(start_); 2296 auto o = ::flatbuffers::Offset<CallInfoRaw>(end); 2297 return o; 2298 } 2299 }; 2300 2301 inline ::flatbuffers::Offset<CallInfoRaw> CreateCallInfoRaw( 2302 ::flatbuffers::FlatBufferBuilder &_fbb, 2303 rpc::CallFlag flags = static_cast<rpc::CallFlag>(0), 2304 int32_t error = 0, 2305 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> signal = 0, 2306 ::flatbuffers::Offset<::flatbuffers::Vector<uint64_t>> cover = 0, 2307 ::flatbuffers::Offset<::flatbuffers::Vector<const rpc::ComparisonRaw *>> comps = 0) { 2308 CallInfoRawBuilder builder_(_fbb); 2309 builder_.add_comps(comps); 2310 builder_.add_cover(cover); 2311 builder_.add_signal(signal); 2312 builder_.add_error(error); 2313 builder_.add_flags(flags); 2314 return builder_.Finish(); 2315 } 2316 2317 inline ::flatbuffers::Offset<CallInfoRaw> CreateCallInfoRawDirect( 2318 ::flatbuffers::FlatBufferBuilder &_fbb, 2319 rpc::CallFlag flags = static_cast<rpc::CallFlag>(0), 2320 int32_t error = 0, 2321 const std::vector<uint64_t> *signal = nullptr, 2322 const std::vector<uint64_t> *cover = nullptr, 2323 const std::vector<rpc::ComparisonRaw> *comps = nullptr) { 2324 auto signal__ = signal ? _fbb.CreateVector<uint64_t>(*signal) : 0; 2325 auto cover__ = cover ? _fbb.CreateVector<uint64_t>(*cover) : 0; 2326 auto comps__ = comps ? _fbb.CreateVectorOfStructs<rpc::ComparisonRaw>(*comps) : 0; 2327 return rpc::CreateCallInfoRaw( 2328 _fbb, 2329 flags, 2330 error, 2331 signal__, 2332 cover__, 2333 comps__); 2334 } 2335 2336 ::flatbuffers::Offset<CallInfoRaw> CreateCallInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const CallInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2337 2338 struct ProgInfoRawT : public ::flatbuffers::NativeTable { 2339 typedef ProgInfoRaw TableType; 2340 std::vector<std::unique_ptr<rpc::CallInfoRawT>> calls{}; 2341 std::vector<std::unique_ptr<rpc::CallInfoRawT>> extra_raw{}; 2342 std::unique_ptr<rpc::CallInfoRawT> extra{}; 2343 uint64_t elapsed = 0; 2344 uint64_t freshness = 0; 2345 ProgInfoRawT() = default; 2346 ProgInfoRawT(const ProgInfoRawT &o); 2347 ProgInfoRawT(ProgInfoRawT&&) FLATBUFFERS_NOEXCEPT = default; 2348 ProgInfoRawT &operator=(ProgInfoRawT o) FLATBUFFERS_NOEXCEPT; 2349 }; 2350 2351 struct ProgInfoRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2352 typedef ProgInfoRawT NativeTableType; 2353 typedef ProgInfoRawBuilder Builder; 2354 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2355 VT_CALLS = 4, 2356 VT_EXTRA_RAW = 6, 2357 VT_EXTRA = 8, 2358 VT_ELAPSED = 10, 2359 VT_FRESHNESS = 12 2360 }; 2361 const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>> *calls() const { 2362 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>> *>(VT_CALLS); 2363 } 2364 const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>> *extra_raw() const { 2365 return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>> *>(VT_EXTRA_RAW); 2366 } 2367 const rpc::CallInfoRaw *extra() const { 2368 return GetPointer<const rpc::CallInfoRaw *>(VT_EXTRA); 2369 } 2370 uint64_t elapsed() const { 2371 return GetField<uint64_t>(VT_ELAPSED, 0); 2372 } 2373 uint64_t freshness() const { 2374 return GetField<uint64_t>(VT_FRESHNESS, 0); 2375 } 2376 bool Verify(::flatbuffers::Verifier &verifier) const { 2377 return VerifyTableStart(verifier) && 2378 VerifyOffset(verifier, VT_CALLS) && 2379 verifier.VerifyVector(calls()) && 2380 verifier.VerifyVectorOfTables(calls()) && 2381 VerifyOffset(verifier, VT_EXTRA_RAW) && 2382 verifier.VerifyVector(extra_raw()) && 2383 verifier.VerifyVectorOfTables(extra_raw()) && 2384 VerifyOffset(verifier, VT_EXTRA) && 2385 verifier.VerifyTable(extra()) && 2386 VerifyField<uint64_t>(verifier, VT_ELAPSED, 8) && 2387 VerifyField<uint64_t>(verifier, VT_FRESHNESS, 8) && 2388 verifier.EndTable(); 2389 } 2390 ProgInfoRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2391 void UnPackTo(ProgInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2392 static ::flatbuffers::Offset<ProgInfoRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2393 }; 2394 2395 struct ProgInfoRawBuilder { 2396 typedef ProgInfoRaw Table; 2397 ::flatbuffers::FlatBufferBuilder &fbb_; 2398 ::flatbuffers::uoffset_t start_; 2399 void add_calls(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>>> calls) { 2400 fbb_.AddOffset(ProgInfoRaw::VT_CALLS, calls); 2401 } 2402 void add_extra_raw(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>>> extra_raw) { 2403 fbb_.AddOffset(ProgInfoRaw::VT_EXTRA_RAW, extra_raw); 2404 } 2405 void add_extra(::flatbuffers::Offset<rpc::CallInfoRaw> extra) { 2406 fbb_.AddOffset(ProgInfoRaw::VT_EXTRA, extra); 2407 } 2408 void add_elapsed(uint64_t elapsed) { 2409 fbb_.AddElement<uint64_t>(ProgInfoRaw::VT_ELAPSED, elapsed, 0); 2410 } 2411 void add_freshness(uint64_t freshness) { 2412 fbb_.AddElement<uint64_t>(ProgInfoRaw::VT_FRESHNESS, freshness, 0); 2413 } 2414 explicit ProgInfoRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2415 : fbb_(_fbb) { 2416 start_ = fbb_.StartTable(); 2417 } 2418 ::flatbuffers::Offset<ProgInfoRaw> Finish() { 2419 const auto end = fbb_.EndTable(start_); 2420 auto o = ::flatbuffers::Offset<ProgInfoRaw>(end); 2421 return o; 2422 } 2423 }; 2424 2425 inline ::flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw( 2426 ::flatbuffers::FlatBufferBuilder &_fbb, 2427 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>>> calls = 0, 2428 ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<rpc::CallInfoRaw>>> extra_raw = 0, 2429 ::flatbuffers::Offset<rpc::CallInfoRaw> extra = 0, 2430 uint64_t elapsed = 0, 2431 uint64_t freshness = 0) { 2432 ProgInfoRawBuilder builder_(_fbb); 2433 builder_.add_freshness(freshness); 2434 builder_.add_elapsed(elapsed); 2435 builder_.add_extra(extra); 2436 builder_.add_extra_raw(extra_raw); 2437 builder_.add_calls(calls); 2438 return builder_.Finish(); 2439 } 2440 2441 inline ::flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRawDirect( 2442 ::flatbuffers::FlatBufferBuilder &_fbb, 2443 const std::vector<::flatbuffers::Offset<rpc::CallInfoRaw>> *calls = nullptr, 2444 const std::vector<::flatbuffers::Offset<rpc::CallInfoRaw>> *extra_raw = nullptr, 2445 ::flatbuffers::Offset<rpc::CallInfoRaw> extra = 0, 2446 uint64_t elapsed = 0, 2447 uint64_t freshness = 0) { 2448 auto calls__ = calls ? _fbb.CreateVector<::flatbuffers::Offset<rpc::CallInfoRaw>>(*calls) : 0; 2449 auto extra_raw__ = extra_raw ? _fbb.CreateVector<::flatbuffers::Offset<rpc::CallInfoRaw>>(*extra_raw) : 0; 2450 return rpc::CreateProgInfoRaw( 2451 _fbb, 2452 calls__, 2453 extra_raw__, 2454 extra, 2455 elapsed, 2456 freshness); 2457 } 2458 2459 ::flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2460 2461 struct ExecResultRawT : public ::flatbuffers::NativeTable { 2462 typedef ExecResultRaw TableType; 2463 int64_t id = 0; 2464 int32_t proc = 0; 2465 std::vector<uint8_t> output{}; 2466 bool hanged = false; 2467 std::string error{}; 2468 std::unique_ptr<rpc::ProgInfoRawT> info{}; 2469 ExecResultRawT() = default; 2470 ExecResultRawT(const ExecResultRawT &o); 2471 ExecResultRawT(ExecResultRawT&&) FLATBUFFERS_NOEXCEPT = default; 2472 ExecResultRawT &operator=(ExecResultRawT o) FLATBUFFERS_NOEXCEPT; 2473 }; 2474 2475 struct ExecResultRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2476 typedef ExecResultRawT NativeTableType; 2477 typedef ExecResultRawBuilder Builder; 2478 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2479 VT_ID = 4, 2480 VT_PROC = 6, 2481 VT_OUTPUT = 8, 2482 VT_HANGED = 10, 2483 VT_ERROR = 12, 2484 VT_INFO = 14 2485 }; 2486 int64_t id() const { 2487 return GetField<int64_t>(VT_ID, 0); 2488 } 2489 int32_t proc() const { 2490 return GetField<int32_t>(VT_PROC, 0); 2491 } 2492 const ::flatbuffers::Vector<uint8_t> *output() const { 2493 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_OUTPUT); 2494 } 2495 bool hanged() const { 2496 return GetField<uint8_t>(VT_HANGED, 0) != 0; 2497 } 2498 const ::flatbuffers::String *error() const { 2499 return GetPointer<const ::flatbuffers::String *>(VT_ERROR); 2500 } 2501 const rpc::ProgInfoRaw *info() const { 2502 return GetPointer<const rpc::ProgInfoRaw *>(VT_INFO); 2503 } 2504 bool Verify(::flatbuffers::Verifier &verifier) const { 2505 return VerifyTableStart(verifier) && 2506 VerifyField<int64_t>(verifier, VT_ID, 8) && 2507 VerifyField<int32_t>(verifier, VT_PROC, 4) && 2508 VerifyOffset(verifier, VT_OUTPUT) && 2509 verifier.VerifyVector(output()) && 2510 VerifyField<uint8_t>(verifier, VT_HANGED, 1) && 2511 VerifyOffset(verifier, VT_ERROR) && 2512 verifier.VerifyString(error()) && 2513 VerifyOffset(verifier, VT_INFO) && 2514 verifier.VerifyTable(info()) && 2515 verifier.EndTable(); 2516 } 2517 ExecResultRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2518 void UnPackTo(ExecResultRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2519 static ::flatbuffers::Offset<ExecResultRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecResultRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2520 }; 2521 2522 struct ExecResultRawBuilder { 2523 typedef ExecResultRaw Table; 2524 ::flatbuffers::FlatBufferBuilder &fbb_; 2525 ::flatbuffers::uoffset_t start_; 2526 void add_id(int64_t id) { 2527 fbb_.AddElement<int64_t>(ExecResultRaw::VT_ID, id, 0); 2528 } 2529 void add_proc(int32_t proc) { 2530 fbb_.AddElement<int32_t>(ExecResultRaw::VT_PROC, proc, 0); 2531 } 2532 void add_output(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> output) { 2533 fbb_.AddOffset(ExecResultRaw::VT_OUTPUT, output); 2534 } 2535 void add_hanged(bool hanged) { 2536 fbb_.AddElement<uint8_t>(ExecResultRaw::VT_HANGED, static_cast<uint8_t>(hanged), 0); 2537 } 2538 void add_error(::flatbuffers::Offset<::flatbuffers::String> error) { 2539 fbb_.AddOffset(ExecResultRaw::VT_ERROR, error); 2540 } 2541 void add_info(::flatbuffers::Offset<rpc::ProgInfoRaw> info) { 2542 fbb_.AddOffset(ExecResultRaw::VT_INFO, info); 2543 } 2544 explicit ExecResultRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2545 : fbb_(_fbb) { 2546 start_ = fbb_.StartTable(); 2547 } 2548 ::flatbuffers::Offset<ExecResultRaw> Finish() { 2549 const auto end = fbb_.EndTable(start_); 2550 auto o = ::flatbuffers::Offset<ExecResultRaw>(end); 2551 return o; 2552 } 2553 }; 2554 2555 inline ::flatbuffers::Offset<ExecResultRaw> CreateExecResultRaw( 2556 ::flatbuffers::FlatBufferBuilder &_fbb, 2557 int64_t id = 0, 2558 int32_t proc = 0, 2559 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> output = 0, 2560 bool hanged = false, 2561 ::flatbuffers::Offset<::flatbuffers::String> error = 0, 2562 ::flatbuffers::Offset<rpc::ProgInfoRaw> info = 0) { 2563 ExecResultRawBuilder builder_(_fbb); 2564 builder_.add_id(id); 2565 builder_.add_info(info); 2566 builder_.add_error(error); 2567 builder_.add_output(output); 2568 builder_.add_proc(proc); 2569 builder_.add_hanged(hanged); 2570 return builder_.Finish(); 2571 } 2572 2573 inline ::flatbuffers::Offset<ExecResultRaw> CreateExecResultRawDirect( 2574 ::flatbuffers::FlatBufferBuilder &_fbb, 2575 int64_t id = 0, 2576 int32_t proc = 0, 2577 const std::vector<uint8_t> *output = nullptr, 2578 bool hanged = false, 2579 const char *error = nullptr, 2580 ::flatbuffers::Offset<rpc::ProgInfoRaw> info = 0) { 2581 auto output__ = output ? _fbb.CreateVector<uint8_t>(*output) : 0; 2582 auto error__ = error ? _fbb.CreateString(error) : 0; 2583 return rpc::CreateExecResultRaw( 2584 _fbb, 2585 id, 2586 proc, 2587 output__, 2588 hanged, 2589 error__, 2590 info); 2591 } 2592 2593 ::flatbuffers::Offset<ExecResultRaw> CreateExecResultRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecResultRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2594 2595 struct StateResultRawT : public ::flatbuffers::NativeTable { 2596 typedef StateResultRaw TableType; 2597 std::vector<uint8_t> data{}; 2598 }; 2599 2600 struct StateResultRaw FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2601 typedef StateResultRawT NativeTableType; 2602 typedef StateResultRawBuilder Builder; 2603 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2604 VT_DATA = 4 2605 }; 2606 const ::flatbuffers::Vector<uint8_t> *data() const { 2607 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_DATA); 2608 } 2609 bool Verify(::flatbuffers::Verifier &verifier) const { 2610 return VerifyTableStart(verifier) && 2611 VerifyOffset(verifier, VT_DATA) && 2612 verifier.VerifyVector(data()) && 2613 verifier.EndTable(); 2614 } 2615 StateResultRawT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2616 void UnPackTo(StateResultRawT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2617 static ::flatbuffers::Offset<StateResultRaw> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2618 }; 2619 2620 struct StateResultRawBuilder { 2621 typedef StateResultRaw Table; 2622 ::flatbuffers::FlatBufferBuilder &fbb_; 2623 ::flatbuffers::uoffset_t start_; 2624 void add_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data) { 2625 fbb_.AddOffset(StateResultRaw::VT_DATA, data); 2626 } 2627 explicit StateResultRawBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2628 : fbb_(_fbb) { 2629 start_ = fbb_.StartTable(); 2630 } 2631 ::flatbuffers::Offset<StateResultRaw> Finish() { 2632 const auto end = fbb_.EndTable(start_); 2633 auto o = ::flatbuffers::Offset<StateResultRaw>(end); 2634 return o; 2635 } 2636 }; 2637 2638 inline ::flatbuffers::Offset<StateResultRaw> CreateStateResultRaw( 2639 ::flatbuffers::FlatBufferBuilder &_fbb, 2640 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> data = 0) { 2641 StateResultRawBuilder builder_(_fbb); 2642 builder_.add_data(data); 2643 return builder_.Finish(); 2644 } 2645 2646 inline ::flatbuffers::Offset<StateResultRaw> CreateStateResultRawDirect( 2647 ::flatbuffers::FlatBufferBuilder &_fbb, 2648 const std::vector<uint8_t> *data = nullptr) { 2649 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0; 2650 return rpc::CreateStateResultRaw( 2651 _fbb, 2652 data__); 2653 } 2654 2655 ::flatbuffers::Offset<StateResultRaw> CreateStateResultRaw(::flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2656 2657 struct SnapshotHeaderT : public ::flatbuffers::NativeTable { 2658 typedef SnapshotHeader TableType; 2659 rpc::SnapshotState state = rpc::SnapshotState::Initial; 2660 uint32_t output_offset = 0; 2661 uint32_t output_size = 0; 2662 }; 2663 2664 struct SnapshotHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2665 typedef SnapshotHeaderT NativeTableType; 2666 typedef SnapshotHeaderBuilder Builder; 2667 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2668 VT_STATE = 4, 2669 VT_OUTPUT_OFFSET = 6, 2670 VT_OUTPUT_SIZE = 8 2671 }; 2672 rpc::SnapshotState state() const { 2673 return static_cast<rpc::SnapshotState>(GetField<uint64_t>(VT_STATE, 0)); 2674 } 2675 uint32_t output_offset() const { 2676 return GetField<uint32_t>(VT_OUTPUT_OFFSET, 0); 2677 } 2678 uint32_t output_size() const { 2679 return GetField<uint32_t>(VT_OUTPUT_SIZE, 0); 2680 } 2681 bool Verify(::flatbuffers::Verifier &verifier) const { 2682 return VerifyTableStart(verifier) && 2683 VerifyField<uint64_t>(verifier, VT_STATE, 8) && 2684 VerifyField<uint32_t>(verifier, VT_OUTPUT_OFFSET, 4) && 2685 VerifyField<uint32_t>(verifier, VT_OUTPUT_SIZE, 4) && 2686 verifier.EndTable(); 2687 } 2688 SnapshotHeaderT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2689 void UnPackTo(SnapshotHeaderT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2690 static ::flatbuffers::Offset<SnapshotHeader> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHeaderT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2691 }; 2692 2693 struct SnapshotHeaderBuilder { 2694 typedef SnapshotHeader Table; 2695 ::flatbuffers::FlatBufferBuilder &fbb_; 2696 ::flatbuffers::uoffset_t start_; 2697 void add_state(rpc::SnapshotState state) { 2698 fbb_.AddElement<uint64_t>(SnapshotHeader::VT_STATE, static_cast<uint64_t>(state), 0); 2699 } 2700 void add_output_offset(uint32_t output_offset) { 2701 fbb_.AddElement<uint32_t>(SnapshotHeader::VT_OUTPUT_OFFSET, output_offset, 0); 2702 } 2703 void add_output_size(uint32_t output_size) { 2704 fbb_.AddElement<uint32_t>(SnapshotHeader::VT_OUTPUT_SIZE, output_size, 0); 2705 } 2706 explicit SnapshotHeaderBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2707 : fbb_(_fbb) { 2708 start_ = fbb_.StartTable(); 2709 } 2710 ::flatbuffers::Offset<SnapshotHeader> Finish() { 2711 const auto end = fbb_.EndTable(start_); 2712 auto o = ::flatbuffers::Offset<SnapshotHeader>(end); 2713 return o; 2714 } 2715 }; 2716 2717 inline ::flatbuffers::Offset<SnapshotHeader> CreateSnapshotHeader( 2718 ::flatbuffers::FlatBufferBuilder &_fbb, 2719 rpc::SnapshotState state = rpc::SnapshotState::Initial, 2720 uint32_t output_offset = 0, 2721 uint32_t output_size = 0) { 2722 SnapshotHeaderBuilder builder_(_fbb); 2723 builder_.add_state(state); 2724 builder_.add_output_size(output_size); 2725 builder_.add_output_offset(output_offset); 2726 return builder_.Finish(); 2727 } 2728 2729 ::flatbuffers::Offset<SnapshotHeader> CreateSnapshotHeader(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHeaderT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2730 2731 struct SnapshotHandshakeT : public ::flatbuffers::NativeTable { 2732 typedef SnapshotHandshake TableType; 2733 bool cover_edges = false; 2734 bool kernel_64_bit = false; 2735 int32_t slowdown = 0; 2736 int32_t syscall_timeout_ms = 0; 2737 int32_t program_timeout_ms = 0; 2738 rpc::Feature features = static_cast<rpc::Feature>(0); 2739 rpc::ExecEnv env_flags = static_cast<rpc::ExecEnv>(0); 2740 int64_t sandbox_arg = 0; 2741 }; 2742 2743 struct SnapshotHandshake FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2744 typedef SnapshotHandshakeT NativeTableType; 2745 typedef SnapshotHandshakeBuilder Builder; 2746 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2747 VT_COVER_EDGES = 4, 2748 VT_KERNEL_64_BIT = 6, 2749 VT_SLOWDOWN = 8, 2750 VT_SYSCALL_TIMEOUT_MS = 10, 2751 VT_PROGRAM_TIMEOUT_MS = 12, 2752 VT_FEATURES = 14, 2753 VT_ENV_FLAGS = 16, 2754 VT_SANDBOX_ARG = 18 2755 }; 2756 bool cover_edges() const { 2757 return GetField<uint8_t>(VT_COVER_EDGES, 0) != 0; 2758 } 2759 bool kernel_64_bit() const { 2760 return GetField<uint8_t>(VT_KERNEL_64_BIT, 0) != 0; 2761 } 2762 int32_t slowdown() const { 2763 return GetField<int32_t>(VT_SLOWDOWN, 0); 2764 } 2765 int32_t syscall_timeout_ms() const { 2766 return GetField<int32_t>(VT_SYSCALL_TIMEOUT_MS, 0); 2767 } 2768 int32_t program_timeout_ms() const { 2769 return GetField<int32_t>(VT_PROGRAM_TIMEOUT_MS, 0); 2770 } 2771 rpc::Feature features() const { 2772 return static_cast<rpc::Feature>(GetField<uint64_t>(VT_FEATURES, 0)); 2773 } 2774 rpc::ExecEnv env_flags() const { 2775 return static_cast<rpc::ExecEnv>(GetField<uint64_t>(VT_ENV_FLAGS, 0)); 2776 } 2777 int64_t sandbox_arg() const { 2778 return GetField<int64_t>(VT_SANDBOX_ARG, 0); 2779 } 2780 bool Verify(::flatbuffers::Verifier &verifier) const { 2781 return VerifyTableStart(verifier) && 2782 VerifyField<uint8_t>(verifier, VT_COVER_EDGES, 1) && 2783 VerifyField<uint8_t>(verifier, VT_KERNEL_64_BIT, 1) && 2784 VerifyField<int32_t>(verifier, VT_SLOWDOWN, 4) && 2785 VerifyField<int32_t>(verifier, VT_SYSCALL_TIMEOUT_MS, 4) && 2786 VerifyField<int32_t>(verifier, VT_PROGRAM_TIMEOUT_MS, 4) && 2787 VerifyField<uint64_t>(verifier, VT_FEATURES, 8) && 2788 VerifyField<uint64_t>(verifier, VT_ENV_FLAGS, 8) && 2789 VerifyField<int64_t>(verifier, VT_SANDBOX_ARG, 8) && 2790 verifier.EndTable(); 2791 } 2792 SnapshotHandshakeT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2793 void UnPackTo(SnapshotHandshakeT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2794 static ::flatbuffers::Offset<SnapshotHandshake> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHandshakeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2795 }; 2796 2797 struct SnapshotHandshakeBuilder { 2798 typedef SnapshotHandshake Table; 2799 ::flatbuffers::FlatBufferBuilder &fbb_; 2800 ::flatbuffers::uoffset_t start_; 2801 void add_cover_edges(bool cover_edges) { 2802 fbb_.AddElement<uint8_t>(SnapshotHandshake::VT_COVER_EDGES, static_cast<uint8_t>(cover_edges), 0); 2803 } 2804 void add_kernel_64_bit(bool kernel_64_bit) { 2805 fbb_.AddElement<uint8_t>(SnapshotHandshake::VT_KERNEL_64_BIT, static_cast<uint8_t>(kernel_64_bit), 0); 2806 } 2807 void add_slowdown(int32_t slowdown) { 2808 fbb_.AddElement<int32_t>(SnapshotHandshake::VT_SLOWDOWN, slowdown, 0); 2809 } 2810 void add_syscall_timeout_ms(int32_t syscall_timeout_ms) { 2811 fbb_.AddElement<int32_t>(SnapshotHandshake::VT_SYSCALL_TIMEOUT_MS, syscall_timeout_ms, 0); 2812 } 2813 void add_program_timeout_ms(int32_t program_timeout_ms) { 2814 fbb_.AddElement<int32_t>(SnapshotHandshake::VT_PROGRAM_TIMEOUT_MS, program_timeout_ms, 0); 2815 } 2816 void add_features(rpc::Feature features) { 2817 fbb_.AddElement<uint64_t>(SnapshotHandshake::VT_FEATURES, static_cast<uint64_t>(features), 0); 2818 } 2819 void add_env_flags(rpc::ExecEnv env_flags) { 2820 fbb_.AddElement<uint64_t>(SnapshotHandshake::VT_ENV_FLAGS, static_cast<uint64_t>(env_flags), 0); 2821 } 2822 void add_sandbox_arg(int64_t sandbox_arg) { 2823 fbb_.AddElement<int64_t>(SnapshotHandshake::VT_SANDBOX_ARG, sandbox_arg, 0); 2824 } 2825 explicit SnapshotHandshakeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2826 : fbb_(_fbb) { 2827 start_ = fbb_.StartTable(); 2828 } 2829 ::flatbuffers::Offset<SnapshotHandshake> Finish() { 2830 const auto end = fbb_.EndTable(start_); 2831 auto o = ::flatbuffers::Offset<SnapshotHandshake>(end); 2832 return o; 2833 } 2834 }; 2835 2836 inline ::flatbuffers::Offset<SnapshotHandshake> CreateSnapshotHandshake( 2837 ::flatbuffers::FlatBufferBuilder &_fbb, 2838 bool cover_edges = false, 2839 bool kernel_64_bit = false, 2840 int32_t slowdown = 0, 2841 int32_t syscall_timeout_ms = 0, 2842 int32_t program_timeout_ms = 0, 2843 rpc::Feature features = static_cast<rpc::Feature>(0), 2844 rpc::ExecEnv env_flags = static_cast<rpc::ExecEnv>(0), 2845 int64_t sandbox_arg = 0) { 2846 SnapshotHandshakeBuilder builder_(_fbb); 2847 builder_.add_sandbox_arg(sandbox_arg); 2848 builder_.add_env_flags(env_flags); 2849 builder_.add_features(features); 2850 builder_.add_program_timeout_ms(program_timeout_ms); 2851 builder_.add_syscall_timeout_ms(syscall_timeout_ms); 2852 builder_.add_slowdown(slowdown); 2853 builder_.add_kernel_64_bit(kernel_64_bit); 2854 builder_.add_cover_edges(cover_edges); 2855 return builder_.Finish(); 2856 } 2857 2858 ::flatbuffers::Offset<SnapshotHandshake> CreateSnapshotHandshake(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHandshakeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2859 2860 struct SnapshotRequestT : public ::flatbuffers::NativeTable { 2861 typedef SnapshotRequest TableType; 2862 rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0); 2863 int32_t num_calls = 0; 2864 uint64_t all_call_signal = 0; 2865 bool all_extra_signal = false; 2866 std::vector<uint8_t> prog_data{}; 2867 }; 2868 2869 struct SnapshotRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { 2870 typedef SnapshotRequestT NativeTableType; 2871 typedef SnapshotRequestBuilder Builder; 2872 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { 2873 VT_EXEC_FLAGS = 4, 2874 VT_NUM_CALLS = 6, 2875 VT_ALL_CALL_SIGNAL = 8, 2876 VT_ALL_EXTRA_SIGNAL = 10, 2877 VT_PROG_DATA = 12 2878 }; 2879 rpc::ExecFlag exec_flags() const { 2880 return static_cast<rpc::ExecFlag>(GetField<uint64_t>(VT_EXEC_FLAGS, 0)); 2881 } 2882 int32_t num_calls() const { 2883 return GetField<int32_t>(VT_NUM_CALLS, 0); 2884 } 2885 uint64_t all_call_signal() const { 2886 return GetField<uint64_t>(VT_ALL_CALL_SIGNAL, 0); 2887 } 2888 bool all_extra_signal() const { 2889 return GetField<uint8_t>(VT_ALL_EXTRA_SIGNAL, 0) != 0; 2890 } 2891 const ::flatbuffers::Vector<uint8_t> *prog_data() const { 2892 return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PROG_DATA); 2893 } 2894 bool Verify(::flatbuffers::Verifier &verifier) const { 2895 return VerifyTableStart(verifier) && 2896 VerifyField<uint64_t>(verifier, VT_EXEC_FLAGS, 8) && 2897 VerifyField<int32_t>(verifier, VT_NUM_CALLS, 4) && 2898 VerifyField<uint64_t>(verifier, VT_ALL_CALL_SIGNAL, 8) && 2899 VerifyField<uint8_t>(verifier, VT_ALL_EXTRA_SIGNAL, 1) && 2900 VerifyOffset(verifier, VT_PROG_DATA) && 2901 verifier.VerifyVector(prog_data()) && 2902 verifier.EndTable(); 2903 } 2904 SnapshotRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2905 void UnPackTo(SnapshotRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; 2906 static ::flatbuffers::Offset<SnapshotRequest> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2907 }; 2908 2909 struct SnapshotRequestBuilder { 2910 typedef SnapshotRequest Table; 2911 ::flatbuffers::FlatBufferBuilder &fbb_; 2912 ::flatbuffers::uoffset_t start_; 2913 void add_exec_flags(rpc::ExecFlag exec_flags) { 2914 fbb_.AddElement<uint64_t>(SnapshotRequest::VT_EXEC_FLAGS, static_cast<uint64_t>(exec_flags), 0); 2915 } 2916 void add_num_calls(int32_t num_calls) { 2917 fbb_.AddElement<int32_t>(SnapshotRequest::VT_NUM_CALLS, num_calls, 0); 2918 } 2919 void add_all_call_signal(uint64_t all_call_signal) { 2920 fbb_.AddElement<uint64_t>(SnapshotRequest::VT_ALL_CALL_SIGNAL, all_call_signal, 0); 2921 } 2922 void add_all_extra_signal(bool all_extra_signal) { 2923 fbb_.AddElement<uint8_t>(SnapshotRequest::VT_ALL_EXTRA_SIGNAL, static_cast<uint8_t>(all_extra_signal), 0); 2924 } 2925 void add_prog_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> prog_data) { 2926 fbb_.AddOffset(SnapshotRequest::VT_PROG_DATA, prog_data); 2927 } 2928 explicit SnapshotRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb) 2929 : fbb_(_fbb) { 2930 start_ = fbb_.StartTable(); 2931 } 2932 ::flatbuffers::Offset<SnapshotRequest> Finish() { 2933 const auto end = fbb_.EndTable(start_); 2934 auto o = ::flatbuffers::Offset<SnapshotRequest>(end); 2935 return o; 2936 } 2937 }; 2938 2939 inline ::flatbuffers::Offset<SnapshotRequest> CreateSnapshotRequest( 2940 ::flatbuffers::FlatBufferBuilder &_fbb, 2941 rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0), 2942 int32_t num_calls = 0, 2943 uint64_t all_call_signal = 0, 2944 bool all_extra_signal = false, 2945 ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> prog_data = 0) { 2946 SnapshotRequestBuilder builder_(_fbb); 2947 builder_.add_all_call_signal(all_call_signal); 2948 builder_.add_exec_flags(exec_flags); 2949 builder_.add_prog_data(prog_data); 2950 builder_.add_num_calls(num_calls); 2951 builder_.add_all_extra_signal(all_extra_signal); 2952 return builder_.Finish(); 2953 } 2954 2955 inline ::flatbuffers::Offset<SnapshotRequest> CreateSnapshotRequestDirect( 2956 ::flatbuffers::FlatBufferBuilder &_fbb, 2957 rpc::ExecFlag exec_flags = static_cast<rpc::ExecFlag>(0), 2958 int32_t num_calls = 0, 2959 uint64_t all_call_signal = 0, 2960 bool all_extra_signal = false, 2961 const std::vector<uint8_t> *prog_data = nullptr) { 2962 auto prog_data__ = prog_data ? _fbb.CreateVector<uint8_t>(*prog_data) : 0; 2963 return rpc::CreateSnapshotRequest( 2964 _fbb, 2965 exec_flags, 2966 num_calls, 2967 all_call_signal, 2968 all_extra_signal, 2969 prog_data__); 2970 } 2971 2972 ::flatbuffers::Offset<SnapshotRequest> CreateSnapshotRequest(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); 2973 2974 inline ConnectHelloRawT *ConnectHelloRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 2975 auto _o = std::unique_ptr<ConnectHelloRawT>(new ConnectHelloRawT()); 2976 UnPackTo(_o.get(), _resolver); 2977 return _o.release(); 2978 } 2979 2980 inline void ConnectHelloRaw::UnPackTo(ConnectHelloRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 2981 (void)_o; 2982 (void)_resolver; 2983 { auto _e = cookie(); _o->cookie = _e; } 2984 } 2985 2986 inline ::flatbuffers::Offset<ConnectHelloRaw> ConnectHelloRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectHelloRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 2987 return CreateConnectHelloRaw(_fbb, _o, _rehasher); 2988 } 2989 2990 inline ::flatbuffers::Offset<ConnectHelloRaw> CreateConnectHelloRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectHelloRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 2991 (void)_rehasher; 2992 (void)_o; 2993 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ConnectHelloRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 2994 auto _cookie = _o->cookie; 2995 return rpc::CreateConnectHelloRaw( 2996 _fbb, 2997 _cookie); 2998 } 2999 3000 inline ConnectRequestRawT *ConnectRequestRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3001 auto _o = std::unique_ptr<ConnectRequestRawT>(new ConnectRequestRawT()); 3002 UnPackTo(_o.get(), _resolver); 3003 return _o.release(); 3004 } 3005 3006 inline void ConnectRequestRaw::UnPackTo(ConnectRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3007 (void)_o; 3008 (void)_resolver; 3009 { auto _e = cookie(); _o->cookie = _e; } 3010 { auto _e = id(); _o->id = _e; } 3011 { auto _e = arch(); if (_e) _o->arch = _e->str(); } 3012 { auto _e = git_revision(); if (_e) _o->git_revision = _e->str(); } 3013 { auto _e = syz_revision(); if (_e) _o->syz_revision = _e->str(); } 3014 } 3015 3016 inline ::flatbuffers::Offset<ConnectRequestRaw> ConnectRequestRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3017 return CreateConnectRequestRaw(_fbb, _o, _rehasher); 3018 } 3019 3020 inline ::flatbuffers::Offset<ConnectRequestRaw> CreateConnectRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3021 (void)_rehasher; 3022 (void)_o; 3023 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ConnectRequestRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3024 auto _cookie = _o->cookie; 3025 auto _id = _o->id; 3026 auto _arch = _o->arch.empty() ? 0 : _fbb.CreateString(_o->arch); 3027 auto _git_revision = _o->git_revision.empty() ? 0 : _fbb.CreateString(_o->git_revision); 3028 auto _syz_revision = _o->syz_revision.empty() ? 0 : _fbb.CreateString(_o->syz_revision); 3029 return rpc::CreateConnectRequestRaw( 3030 _fbb, 3031 _cookie, 3032 _id, 3033 _arch, 3034 _git_revision, 3035 _syz_revision); 3036 } 3037 3038 inline ConnectReplyRawT *ConnectReplyRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3039 auto _o = std::unique_ptr<ConnectReplyRawT>(new ConnectReplyRawT()); 3040 UnPackTo(_o.get(), _resolver); 3041 return _o.release(); 3042 } 3043 3044 inline void ConnectReplyRaw::UnPackTo(ConnectReplyRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3045 (void)_o; 3046 (void)_resolver; 3047 { auto _e = debug(); _o->debug = _e; } 3048 { auto _e = cover(); _o->cover = _e; } 3049 { auto _e = cover_edges(); _o->cover_edges = _e; } 3050 { auto _e = kernel_64_bit(); _o->kernel_64_bit = _e; } 3051 { auto _e = procs(); _o->procs = _e; } 3052 { auto _e = slowdown(); _o->slowdown = _e; } 3053 { auto _e = syscall_timeout_ms(); _o->syscall_timeout_ms = _e; } 3054 { auto _e = program_timeout_ms(); _o->program_timeout_ms = _e; } 3055 { 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(); } } else { _o->leak_frames.resize(0); } } 3056 { 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(); } } else { _o->race_frames.resize(0); } } 3057 { auto _e = features(); _o->features = _e; } 3058 { 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(); } } else { _o->files.resize(0); } } 3059 } 3060 3061 inline ::flatbuffers::Offset<ConnectReplyRaw> ConnectReplyRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3062 return CreateConnectReplyRaw(_fbb, _o, _rehasher); 3063 } 3064 3065 inline ::flatbuffers::Offset<ConnectReplyRaw> CreateConnectReplyRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ConnectReplyRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3066 (void)_rehasher; 3067 (void)_o; 3068 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ConnectReplyRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3069 auto _debug = _o->debug; 3070 auto _cover = _o->cover; 3071 auto _cover_edges = _o->cover_edges; 3072 auto _kernel_64_bit = _o->kernel_64_bit; 3073 auto _procs = _o->procs; 3074 auto _slowdown = _o->slowdown; 3075 auto _syscall_timeout_ms = _o->syscall_timeout_ms; 3076 auto _program_timeout_ms = _o->program_timeout_ms; 3077 auto _leak_frames = _o->leak_frames.size() ? _fbb.CreateVectorOfStrings(_o->leak_frames) : 0; 3078 auto _race_frames = _o->race_frames.size() ? _fbb.CreateVectorOfStrings(_o->race_frames) : 0; 3079 auto _features = _o->features; 3080 auto _files = _o->files.size() ? _fbb.CreateVectorOfStrings(_o->files) : 0; 3081 return rpc::CreateConnectReplyRaw( 3082 _fbb, 3083 _debug, 3084 _cover, 3085 _cover_edges, 3086 _kernel_64_bit, 3087 _procs, 3088 _slowdown, 3089 _syscall_timeout_ms, 3090 _program_timeout_ms, 3091 _leak_frames, 3092 _race_frames, 3093 _features, 3094 _files); 3095 } 3096 3097 inline InfoRequestRawT::InfoRequestRawT(const InfoRequestRawT &o) 3098 : error(o.error) { 3099 features.reserve(o.features.size()); 3100 for (const auto &features_ : o.features) { features.emplace_back((features_) ? new rpc::FeatureInfoRawT(*features_) : nullptr); } 3101 files.reserve(o.files.size()); 3102 for (const auto &files_ : o.files) { files.emplace_back((files_) ? new rpc::FileInfoRawT(*files_) : nullptr); } 3103 } 3104 3105 inline InfoRequestRawT &InfoRequestRawT::operator=(InfoRequestRawT o) FLATBUFFERS_NOEXCEPT { 3106 std::swap(error, o.error); 3107 std::swap(features, o.features); 3108 std::swap(files, o.files); 3109 return *this; 3110 } 3111 3112 inline InfoRequestRawT *InfoRequestRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3113 auto _o = std::unique_ptr<InfoRequestRawT>(new InfoRequestRawT()); 3114 UnPackTo(_o.get(), _resolver); 3115 return _o.release(); 3116 } 3117 3118 inline void InfoRequestRaw::UnPackTo(InfoRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3119 (void)_o; 3120 (void)_resolver; 3121 { auto _e = error(); if (_e) _o->error = _e->str(); } 3122 { auto _e = features(); if (_e) { _o->features.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->features[_i]) { _e->Get(_i)->UnPackTo(_o->features[_i].get(), _resolver); } else { _o->features[_i] = std::unique_ptr<rpc::FeatureInfoRawT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->features.resize(0); } } 3123 { auto _e = files(); if (_e) { _o->files.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->files[_i]) { _e->Get(_i)->UnPackTo(_o->files[_i].get(), _resolver); } else { _o->files[_i] = std::unique_ptr<rpc::FileInfoRawT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->files.resize(0); } } 3124 } 3125 3126 inline ::flatbuffers::Offset<InfoRequestRaw> InfoRequestRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3127 return CreateInfoRequestRaw(_fbb, _o, _rehasher); 3128 } 3129 3130 inline ::flatbuffers::Offset<InfoRequestRaw> CreateInfoRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const InfoRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3131 (void)_rehasher; 3132 (void)_o; 3133 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const InfoRequestRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3134 auto _error = _o->error.empty() ? 0 : _fbb.CreateString(_o->error); 3135 auto _features = _o->features.size() ? _fbb.CreateVector<::flatbuffers::Offset<rpc::FeatureInfoRaw>> (_o->features.size(), [](size_t i, _VectorArgs *__va) { return CreateFeatureInfoRaw(*__va->__fbb, __va->__o->features[i].get(), __va->__rehasher); }, &_va ) : 0; 3136 auto _files = _o->files.size() ? _fbb.CreateVector<::flatbuffers::Offset<rpc::FileInfoRaw>> (_o->files.size(), [](size_t i, _VectorArgs *__va) { return CreateFileInfoRaw(*__va->__fbb, __va->__o->files[i].get(), __va->__rehasher); }, &_va ) : 0; 3137 return rpc::CreateInfoRequestRaw( 3138 _fbb, 3139 _error, 3140 _features, 3141 _files); 3142 } 3143 3144 inline InfoReplyRawT *InfoReplyRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3145 auto _o = std::unique_ptr<InfoReplyRawT>(new InfoReplyRawT()); 3146 UnPackTo(_o.get(), _resolver); 3147 return _o.release(); 3148 } 3149 3150 inline void InfoReplyRaw::UnPackTo(InfoReplyRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3151 (void)_o; 3152 (void)_resolver; 3153 { 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); } } else { _o->cover_filter.resize(0); } } 3154 } 3155 3156 inline ::flatbuffers::Offset<InfoReplyRaw> InfoReplyRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3157 return CreateInfoReplyRaw(_fbb, _o, _rehasher); 3158 } 3159 3160 inline ::flatbuffers::Offset<InfoReplyRaw> CreateInfoReplyRaw(::flatbuffers::FlatBufferBuilder &_fbb, const InfoReplyRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3161 (void)_rehasher; 3162 (void)_o; 3163 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const InfoReplyRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3164 auto _cover_filter = _o->cover_filter.size() ? _fbb.CreateVector(_o->cover_filter) : 0; 3165 return rpc::CreateInfoReplyRaw( 3166 _fbb, 3167 _cover_filter); 3168 } 3169 3170 inline FileInfoRawT *FileInfoRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3171 auto _o = std::unique_ptr<FileInfoRawT>(new FileInfoRawT()); 3172 UnPackTo(_o.get(), _resolver); 3173 return _o.release(); 3174 } 3175 3176 inline void FileInfoRaw::UnPackTo(FileInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3177 (void)_o; 3178 (void)_resolver; 3179 { auto _e = name(); if (_e) _o->name = _e->str(); } 3180 { auto _e = exists(); _o->exists = _e; } 3181 { auto _e = error(); if (_e) _o->error = _e->str(); } 3182 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } 3183 } 3184 3185 inline ::flatbuffers::Offset<FileInfoRaw> FileInfoRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FileInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3186 return CreateFileInfoRaw(_fbb, _o, _rehasher); 3187 } 3188 3189 inline ::flatbuffers::Offset<FileInfoRaw> CreateFileInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const FileInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3190 (void)_rehasher; 3191 (void)_o; 3192 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FileInfoRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3193 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); 3194 auto _exists = _o->exists; 3195 auto _error = _o->error.empty() ? 0 : _fbb.CreateString(_o->error); 3196 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; 3197 return rpc::CreateFileInfoRaw( 3198 _fbb, 3199 _name, 3200 _exists, 3201 _error, 3202 _data); 3203 } 3204 3205 inline GlobInfoRawT *GlobInfoRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3206 auto _o = std::unique_ptr<GlobInfoRawT>(new GlobInfoRawT()); 3207 UnPackTo(_o.get(), _resolver); 3208 return _o.release(); 3209 } 3210 3211 inline void GlobInfoRaw::UnPackTo(GlobInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3212 (void)_o; 3213 (void)_resolver; 3214 { auto _e = name(); if (_e) _o->name = _e->str(); } 3215 { 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(); } } else { _o->files.resize(0); } } 3216 } 3217 3218 inline ::flatbuffers::Offset<GlobInfoRaw> GlobInfoRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3219 return CreateGlobInfoRaw(_fbb, _o, _rehasher); 3220 } 3221 3222 inline ::flatbuffers::Offset<GlobInfoRaw> CreateGlobInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const GlobInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3223 (void)_rehasher; 3224 (void)_o; 3225 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GlobInfoRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3226 auto _name = _o->name.empty() ? 0 : _fbb.CreateString(_o->name); 3227 auto _files = _o->files.size() ? _fbb.CreateVectorOfStrings(_o->files) : 0; 3228 return rpc::CreateGlobInfoRaw( 3229 _fbb, 3230 _name, 3231 _files); 3232 } 3233 3234 inline FeatureInfoRawT *FeatureInfoRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3235 auto _o = std::unique_ptr<FeatureInfoRawT>(new FeatureInfoRawT()); 3236 UnPackTo(_o.get(), _resolver); 3237 return _o.release(); 3238 } 3239 3240 inline void FeatureInfoRaw::UnPackTo(FeatureInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3241 (void)_o; 3242 (void)_resolver; 3243 { auto _e = id(); _o->id = _e; } 3244 { auto _e = need_setup(); _o->need_setup = _e; } 3245 { auto _e = reason(); if (_e) _o->reason = _e->str(); } 3246 } 3247 3248 inline ::flatbuffers::Offset<FeatureInfoRaw> FeatureInfoRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const FeatureInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3249 return CreateFeatureInfoRaw(_fbb, _o, _rehasher); 3250 } 3251 3252 inline ::flatbuffers::Offset<FeatureInfoRaw> CreateFeatureInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const FeatureInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3253 (void)_rehasher; 3254 (void)_o; 3255 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const FeatureInfoRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3256 auto _id = _o->id; 3257 auto _need_setup = _o->need_setup; 3258 auto _reason = _o->reason.empty() ? 0 : _fbb.CreateString(_o->reason); 3259 return rpc::CreateFeatureInfoRaw( 3260 _fbb, 3261 _id, 3262 _need_setup, 3263 _reason); 3264 } 3265 3266 inline HostMessageRawT *HostMessageRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3267 auto _o = std::unique_ptr<HostMessageRawT>(new HostMessageRawT()); 3268 UnPackTo(_o.get(), _resolver); 3269 return _o.release(); 3270 } 3271 3272 inline void HostMessageRaw::UnPackTo(HostMessageRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3273 (void)_o; 3274 (void)_resolver; 3275 { auto _e = msg_type(); _o->msg.type = _e; } 3276 { auto _e = msg(); if (_e) _o->msg.value = rpc::HostMessagesRawUnion::UnPack(_e, msg_type(), _resolver); } 3277 } 3278 3279 inline ::flatbuffers::Offset<HostMessageRaw> HostMessageRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const HostMessageRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3280 return CreateHostMessageRaw(_fbb, _o, _rehasher); 3281 } 3282 3283 inline ::flatbuffers::Offset<HostMessageRaw> CreateHostMessageRaw(::flatbuffers::FlatBufferBuilder &_fbb, const HostMessageRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3284 (void)_rehasher; 3285 (void)_o; 3286 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const HostMessageRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3287 auto _msg_type = _o->msg.type; 3288 auto _msg = _o->msg.Pack(_fbb); 3289 return rpc::CreateHostMessageRaw( 3290 _fbb, 3291 _msg_type, 3292 _msg); 3293 } 3294 3295 inline ExecutorMessageRawT *ExecutorMessageRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3296 auto _o = std::unique_ptr<ExecutorMessageRawT>(new ExecutorMessageRawT()); 3297 UnPackTo(_o.get(), _resolver); 3298 return _o.release(); 3299 } 3300 3301 inline void ExecutorMessageRaw::UnPackTo(ExecutorMessageRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3302 (void)_o; 3303 (void)_resolver; 3304 { auto _e = msg_type(); _o->msg.type = _e; } 3305 { auto _e = msg(); if (_e) _o->msg.value = rpc::ExecutorMessagesRawUnion::UnPack(_e, msg_type(), _resolver); } 3306 } 3307 3308 inline ::flatbuffers::Offset<ExecutorMessageRaw> ExecutorMessageRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3309 return CreateExecutorMessageRaw(_fbb, _o, _rehasher); 3310 } 3311 3312 inline ::flatbuffers::Offset<ExecutorMessageRaw> CreateExecutorMessageRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutorMessageRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3313 (void)_rehasher; 3314 (void)_o; 3315 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ExecutorMessageRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3316 auto _msg_type = _o->msg.type; 3317 auto _msg = _o->msg.Pack(_fbb); 3318 return rpc::CreateExecutorMessageRaw( 3319 _fbb, 3320 _msg_type, 3321 _msg); 3322 } 3323 3324 inline ExecRequestRawT::ExecRequestRawT(const ExecRequestRawT &o) 3325 : id(o.id), 3326 type(o.type), 3327 avoid(o.avoid), 3328 data(o.data), 3329 exec_opts((o.exec_opts) ? new rpc::ExecOptsRaw(*o.exec_opts) : nullptr), 3330 flags(o.flags), 3331 all_signal(o.all_signal) { 3332 } 3333 3334 inline ExecRequestRawT &ExecRequestRawT::operator=(ExecRequestRawT o) FLATBUFFERS_NOEXCEPT { 3335 std::swap(id, o.id); 3336 std::swap(type, o.type); 3337 std::swap(avoid, o.avoid); 3338 std::swap(data, o.data); 3339 std::swap(exec_opts, o.exec_opts); 3340 std::swap(flags, o.flags); 3341 std::swap(all_signal, o.all_signal); 3342 return *this; 3343 } 3344 3345 inline ExecRequestRawT *ExecRequestRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3346 auto _o = std::unique_ptr<ExecRequestRawT>(new ExecRequestRawT()); 3347 UnPackTo(_o.get(), _resolver); 3348 return _o.release(); 3349 } 3350 3351 inline void ExecRequestRaw::UnPackTo(ExecRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3352 (void)_o; 3353 (void)_resolver; 3354 { auto _e = id(); _o->id = _e; } 3355 { auto _e = type(); _o->type = _e; } 3356 { auto _e = avoid(); _o->avoid = _e; } 3357 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } 3358 { auto _e = exec_opts(); if (_e) _o->exec_opts = std::unique_ptr<rpc::ExecOptsRaw>(new rpc::ExecOptsRaw(*_e)); } 3359 { auto _e = flags(); _o->flags = _e; } 3360 { auto _e = all_signal(); if (_e) { _o->all_signal.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->all_signal[_i] = _e->Get(_i); } } else { _o->all_signal.resize(0); } } 3361 } 3362 3363 inline ::flatbuffers::Offset<ExecRequestRaw> ExecRequestRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3364 return CreateExecRequestRaw(_fbb, _o, _rehasher); 3365 } 3366 3367 inline ::flatbuffers::Offset<ExecRequestRaw> CreateExecRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3368 (void)_rehasher; 3369 (void)_o; 3370 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ExecRequestRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3371 auto _id = _o->id; 3372 auto _type = _o->type; 3373 auto _avoid = _o->avoid; 3374 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; 3375 auto _exec_opts = _o->exec_opts ? _o->exec_opts.get() : nullptr; 3376 auto _flags = _o->flags; 3377 auto _all_signal = _o->all_signal.size() ? _fbb.CreateVector(_o->all_signal) : 0; 3378 return rpc::CreateExecRequestRaw( 3379 _fbb, 3380 _id, 3381 _type, 3382 _avoid, 3383 _data, 3384 _exec_opts, 3385 _flags, 3386 _all_signal); 3387 } 3388 3389 inline SignalUpdateRawT *SignalUpdateRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3390 auto _o = std::unique_ptr<SignalUpdateRawT>(new SignalUpdateRawT()); 3391 UnPackTo(_o.get(), _resolver); 3392 return _o.release(); 3393 } 3394 3395 inline void SignalUpdateRaw::UnPackTo(SignalUpdateRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3396 (void)_o; 3397 (void)_resolver; 3398 { 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); } } else { _o->new_max.resize(0); } } 3399 } 3400 3401 inline ::flatbuffers::Offset<SignalUpdateRaw> SignalUpdateRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3402 return CreateSignalUpdateRaw(_fbb, _o, _rehasher); 3403 } 3404 3405 inline ::flatbuffers::Offset<SignalUpdateRaw> CreateSignalUpdateRaw(::flatbuffers::FlatBufferBuilder &_fbb, const SignalUpdateRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3406 (void)_rehasher; 3407 (void)_o; 3408 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SignalUpdateRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3409 auto _new_max = _o->new_max.size() ? _fbb.CreateVector(_o->new_max) : 0; 3410 return rpc::CreateSignalUpdateRaw( 3411 _fbb, 3412 _new_max); 3413 } 3414 3415 inline CorpusTriagedRawT *CorpusTriagedRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3416 auto _o = std::unique_ptr<CorpusTriagedRawT>(new CorpusTriagedRawT()); 3417 UnPackTo(_o.get(), _resolver); 3418 return _o.release(); 3419 } 3420 3421 inline void CorpusTriagedRaw::UnPackTo(CorpusTriagedRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3422 (void)_o; 3423 (void)_resolver; 3424 } 3425 3426 inline ::flatbuffers::Offset<CorpusTriagedRaw> CorpusTriagedRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3427 return CreateCorpusTriagedRaw(_fbb, _o, _rehasher); 3428 } 3429 3430 inline ::flatbuffers::Offset<CorpusTriagedRaw> CreateCorpusTriagedRaw(::flatbuffers::FlatBufferBuilder &_fbb, const CorpusTriagedRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3431 (void)_rehasher; 3432 (void)_o; 3433 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CorpusTriagedRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3434 return rpc::CreateCorpusTriagedRaw( 3435 _fbb); 3436 } 3437 3438 inline StateRequestRawT *StateRequestRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3439 auto _o = std::unique_ptr<StateRequestRawT>(new StateRequestRawT()); 3440 UnPackTo(_o.get(), _resolver); 3441 return _o.release(); 3442 } 3443 3444 inline void StateRequestRaw::UnPackTo(StateRequestRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3445 (void)_o; 3446 (void)_resolver; 3447 } 3448 3449 inline ::flatbuffers::Offset<StateRequestRaw> StateRequestRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3450 return CreateStateRequestRaw(_fbb, _o, _rehasher); 3451 } 3452 3453 inline ::flatbuffers::Offset<StateRequestRaw> CreateStateRequestRaw(::flatbuffers::FlatBufferBuilder &_fbb, const StateRequestRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3454 (void)_rehasher; 3455 (void)_o; 3456 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StateRequestRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3457 return rpc::CreateStateRequestRaw( 3458 _fbb); 3459 } 3460 3461 inline ExecutingMessageRawT *ExecutingMessageRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3462 auto _o = std::unique_ptr<ExecutingMessageRawT>(new ExecutingMessageRawT()); 3463 UnPackTo(_o.get(), _resolver); 3464 return _o.release(); 3465 } 3466 3467 inline void ExecutingMessageRaw::UnPackTo(ExecutingMessageRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3468 (void)_o; 3469 (void)_resolver; 3470 { auto _e = id(); _o->id = _e; } 3471 { auto _e = proc_id(); _o->proc_id = _e; } 3472 { auto _e = try_(); _o->try_ = _e; } 3473 { auto _e = wait_duration(); _o->wait_duration = _e; } 3474 } 3475 3476 inline ::flatbuffers::Offset<ExecutingMessageRaw> ExecutingMessageRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3477 return CreateExecutingMessageRaw(_fbb, _o, _rehasher); 3478 } 3479 3480 inline ::flatbuffers::Offset<ExecutingMessageRaw> CreateExecutingMessageRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecutingMessageRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3481 (void)_rehasher; 3482 (void)_o; 3483 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ExecutingMessageRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3484 auto _id = _o->id; 3485 auto _proc_id = _o->proc_id; 3486 auto _try_ = _o->try_; 3487 auto _wait_duration = _o->wait_duration; 3488 return rpc::CreateExecutingMessageRaw( 3489 _fbb, 3490 _id, 3491 _proc_id, 3492 _try_, 3493 _wait_duration); 3494 } 3495 3496 inline CallInfoRawT *CallInfoRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3497 auto _o = std::unique_ptr<CallInfoRawT>(new CallInfoRawT()); 3498 UnPackTo(_o.get(), _resolver); 3499 return _o.release(); 3500 } 3501 3502 inline void CallInfoRaw::UnPackTo(CallInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3503 (void)_o; 3504 (void)_resolver; 3505 { auto _e = flags(); _o->flags = _e; } 3506 { auto _e = error(); _o->error = _e; } 3507 { 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); } } else { _o->signal.resize(0); } } 3508 { 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); } } else { _o->cover.resize(0); } } 3509 { 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); } } else { _o->comps.resize(0); } } 3510 } 3511 3512 inline ::flatbuffers::Offset<CallInfoRaw> CallInfoRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const CallInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3513 return CreateCallInfoRaw(_fbb, _o, _rehasher); 3514 } 3515 3516 inline ::flatbuffers::Offset<CallInfoRaw> CreateCallInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const CallInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3517 (void)_rehasher; 3518 (void)_o; 3519 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const CallInfoRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3520 auto _flags = _o->flags; 3521 auto _error = _o->error; 3522 auto _signal = _o->signal.size() ? _fbb.CreateVector(_o->signal) : 0; 3523 auto _cover = _o->cover.size() ? _fbb.CreateVector(_o->cover) : 0; 3524 auto _comps = _o->comps.size() ? _fbb.CreateVectorOfStructs(_o->comps) : 0; 3525 return rpc::CreateCallInfoRaw( 3526 _fbb, 3527 _flags, 3528 _error, 3529 _signal, 3530 _cover, 3531 _comps); 3532 } 3533 3534 inline ProgInfoRawT::ProgInfoRawT(const ProgInfoRawT &o) 3535 : extra((o.extra) ? new rpc::CallInfoRawT(*o.extra) : nullptr), 3536 elapsed(o.elapsed), 3537 freshness(o.freshness) { 3538 calls.reserve(o.calls.size()); 3539 for (const auto &calls_ : o.calls) { calls.emplace_back((calls_) ? new rpc::CallInfoRawT(*calls_) : nullptr); } 3540 extra_raw.reserve(o.extra_raw.size()); 3541 for (const auto &extra_raw_ : o.extra_raw) { extra_raw.emplace_back((extra_raw_) ? new rpc::CallInfoRawT(*extra_raw_) : nullptr); } 3542 } 3543 3544 inline ProgInfoRawT &ProgInfoRawT::operator=(ProgInfoRawT o) FLATBUFFERS_NOEXCEPT { 3545 std::swap(calls, o.calls); 3546 std::swap(extra_raw, o.extra_raw); 3547 std::swap(extra, o.extra); 3548 std::swap(elapsed, o.elapsed); 3549 std::swap(freshness, o.freshness); 3550 return *this; 3551 } 3552 3553 inline ProgInfoRawT *ProgInfoRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3554 auto _o = std::unique_ptr<ProgInfoRawT>(new ProgInfoRawT()); 3555 UnPackTo(_o.get(), _resolver); 3556 return _o.release(); 3557 } 3558 3559 inline void ProgInfoRaw::UnPackTo(ProgInfoRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3560 (void)_o; 3561 (void)_resolver; 3562 { auto _e = calls(); if (_e) { _o->calls.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->calls[_i]) { _e->Get(_i)->UnPackTo(_o->calls[_i].get(), _resolver); } else { _o->calls[_i] = std::unique_ptr<rpc::CallInfoRawT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->calls.resize(0); } } 3563 { auto _e = extra_raw(); if (_e) { _o->extra_raw.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { if(_o->extra_raw[_i]) { _e->Get(_i)->UnPackTo(_o->extra_raw[_i].get(), _resolver); } else { _o->extra_raw[_i] = std::unique_ptr<rpc::CallInfoRawT>(_e->Get(_i)->UnPack(_resolver)); }; } } else { _o->extra_raw.resize(0); } } 3564 { auto _e = extra(); if (_e) { if(_o->extra) { _e->UnPackTo(_o->extra.get(), _resolver); } else { _o->extra = std::unique_ptr<rpc::CallInfoRawT>(_e->UnPack(_resolver)); } } else if (_o->extra) { _o->extra.reset(); } } 3565 { auto _e = elapsed(); _o->elapsed = _e; } 3566 { auto _e = freshness(); _o->freshness = _e; } 3567 } 3568 3569 inline ::flatbuffers::Offset<ProgInfoRaw> ProgInfoRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3570 return CreateProgInfoRaw(_fbb, _o, _rehasher); 3571 } 3572 3573 inline ::flatbuffers::Offset<ProgInfoRaw> CreateProgInfoRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ProgInfoRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3574 (void)_rehasher; 3575 (void)_o; 3576 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ProgInfoRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3577 auto _calls = _o->calls.size() ? _fbb.CreateVector<::flatbuffers::Offset<rpc::CallInfoRaw>> (_o->calls.size(), [](size_t i, _VectorArgs *__va) { return CreateCallInfoRaw(*__va->__fbb, __va->__o->calls[i].get(), __va->__rehasher); }, &_va ) : 0; 3578 auto _extra_raw = _o->extra_raw.size() ? _fbb.CreateVector<::flatbuffers::Offset<rpc::CallInfoRaw>> (_o->extra_raw.size(), [](size_t i, _VectorArgs *__va) { return CreateCallInfoRaw(*__va->__fbb, __va->__o->extra_raw[i].get(), __va->__rehasher); }, &_va ) : 0; 3579 auto _extra = _o->extra ? CreateCallInfoRaw(_fbb, _o->extra.get(), _rehasher) : 0; 3580 auto _elapsed = _o->elapsed; 3581 auto _freshness = _o->freshness; 3582 return rpc::CreateProgInfoRaw( 3583 _fbb, 3584 _calls, 3585 _extra_raw, 3586 _extra, 3587 _elapsed, 3588 _freshness); 3589 } 3590 3591 inline ExecResultRawT::ExecResultRawT(const ExecResultRawT &o) 3592 : id(o.id), 3593 proc(o.proc), 3594 output(o.output), 3595 hanged(o.hanged), 3596 error(o.error), 3597 info((o.info) ? new rpc::ProgInfoRawT(*o.info) : nullptr) { 3598 } 3599 3600 inline ExecResultRawT &ExecResultRawT::operator=(ExecResultRawT o) FLATBUFFERS_NOEXCEPT { 3601 std::swap(id, o.id); 3602 std::swap(proc, o.proc); 3603 std::swap(output, o.output); 3604 std::swap(hanged, o.hanged); 3605 std::swap(error, o.error); 3606 std::swap(info, o.info); 3607 return *this; 3608 } 3609 3610 inline ExecResultRawT *ExecResultRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3611 auto _o = std::unique_ptr<ExecResultRawT>(new ExecResultRawT()); 3612 UnPackTo(_o.get(), _resolver); 3613 return _o.release(); 3614 } 3615 3616 inline void ExecResultRaw::UnPackTo(ExecResultRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3617 (void)_o; 3618 (void)_resolver; 3619 { auto _e = id(); _o->id = _e; } 3620 { auto _e = proc(); _o->proc = _e; } 3621 { auto _e = output(); if (_e) { _o->output.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->output.begin()); } } 3622 { auto _e = hanged(); _o->hanged = _e; } 3623 { auto _e = error(); if (_e) _o->error = _e->str(); } 3624 { auto _e = info(); if (_e) { if(_o->info) { _e->UnPackTo(_o->info.get(), _resolver); } else { _o->info = std::unique_ptr<rpc::ProgInfoRawT>(_e->UnPack(_resolver)); } } else if (_o->info) { _o->info.reset(); } } 3625 } 3626 3627 inline ::flatbuffers::Offset<ExecResultRaw> ExecResultRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ExecResultRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3628 return CreateExecResultRaw(_fbb, _o, _rehasher); 3629 } 3630 3631 inline ::flatbuffers::Offset<ExecResultRaw> CreateExecResultRaw(::flatbuffers::FlatBufferBuilder &_fbb, const ExecResultRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3632 (void)_rehasher; 3633 (void)_o; 3634 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ExecResultRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3635 auto _id = _o->id; 3636 auto _proc = _o->proc; 3637 auto _output = _o->output.size() ? _fbb.CreateVector(_o->output) : 0; 3638 auto _hanged = _o->hanged; 3639 auto _error = _o->error.empty() ? 0 : _fbb.CreateString(_o->error); 3640 auto _info = _o->info ? CreateProgInfoRaw(_fbb, _o->info.get(), _rehasher) : 0; 3641 return rpc::CreateExecResultRaw( 3642 _fbb, 3643 _id, 3644 _proc, 3645 _output, 3646 _hanged, 3647 _error, 3648 _info); 3649 } 3650 3651 inline StateResultRawT *StateResultRaw::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3652 auto _o = std::unique_ptr<StateResultRawT>(new StateResultRawT()); 3653 UnPackTo(_o.get(), _resolver); 3654 return _o.release(); 3655 } 3656 3657 inline void StateResultRaw::UnPackTo(StateResultRawT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3658 (void)_o; 3659 (void)_resolver; 3660 { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } 3661 } 3662 3663 inline ::flatbuffers::Offset<StateResultRaw> StateResultRaw::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3664 return CreateStateResultRaw(_fbb, _o, _rehasher); 3665 } 3666 3667 inline ::flatbuffers::Offset<StateResultRaw> CreateStateResultRaw(::flatbuffers::FlatBufferBuilder &_fbb, const StateResultRawT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3668 (void)_rehasher; 3669 (void)_o; 3670 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const StateResultRawT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3671 auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; 3672 return rpc::CreateStateResultRaw( 3673 _fbb, 3674 _data); 3675 } 3676 3677 inline SnapshotHeaderT *SnapshotHeader::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3678 auto _o = std::unique_ptr<SnapshotHeaderT>(new SnapshotHeaderT()); 3679 UnPackTo(_o.get(), _resolver); 3680 return _o.release(); 3681 } 3682 3683 inline void SnapshotHeader::UnPackTo(SnapshotHeaderT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3684 (void)_o; 3685 (void)_resolver; 3686 { auto _e = state(); _o->state = _e; } 3687 { auto _e = output_offset(); _o->output_offset = _e; } 3688 { auto _e = output_size(); _o->output_size = _e; } 3689 } 3690 3691 inline ::flatbuffers::Offset<SnapshotHeader> SnapshotHeader::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHeaderT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3692 return CreateSnapshotHeader(_fbb, _o, _rehasher); 3693 } 3694 3695 inline ::flatbuffers::Offset<SnapshotHeader> CreateSnapshotHeader(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHeaderT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3696 (void)_rehasher; 3697 (void)_o; 3698 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SnapshotHeaderT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3699 auto _state = _o->state; 3700 auto _output_offset = _o->output_offset; 3701 auto _output_size = _o->output_size; 3702 return rpc::CreateSnapshotHeader( 3703 _fbb, 3704 _state, 3705 _output_offset, 3706 _output_size); 3707 } 3708 3709 inline SnapshotHandshakeT *SnapshotHandshake::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3710 auto _o = std::unique_ptr<SnapshotHandshakeT>(new SnapshotHandshakeT()); 3711 UnPackTo(_o.get(), _resolver); 3712 return _o.release(); 3713 } 3714 3715 inline void SnapshotHandshake::UnPackTo(SnapshotHandshakeT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3716 (void)_o; 3717 (void)_resolver; 3718 { auto _e = cover_edges(); _o->cover_edges = _e; } 3719 { auto _e = kernel_64_bit(); _o->kernel_64_bit = _e; } 3720 { auto _e = slowdown(); _o->slowdown = _e; } 3721 { auto _e = syscall_timeout_ms(); _o->syscall_timeout_ms = _e; } 3722 { auto _e = program_timeout_ms(); _o->program_timeout_ms = _e; } 3723 { auto _e = features(); _o->features = _e; } 3724 { auto _e = env_flags(); _o->env_flags = _e; } 3725 { auto _e = sandbox_arg(); _o->sandbox_arg = _e; } 3726 } 3727 3728 inline ::flatbuffers::Offset<SnapshotHandshake> SnapshotHandshake::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHandshakeT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3729 return CreateSnapshotHandshake(_fbb, _o, _rehasher); 3730 } 3731 3732 inline ::flatbuffers::Offset<SnapshotHandshake> CreateSnapshotHandshake(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotHandshakeT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3733 (void)_rehasher; 3734 (void)_o; 3735 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SnapshotHandshakeT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3736 auto _cover_edges = _o->cover_edges; 3737 auto _kernel_64_bit = _o->kernel_64_bit; 3738 auto _slowdown = _o->slowdown; 3739 auto _syscall_timeout_ms = _o->syscall_timeout_ms; 3740 auto _program_timeout_ms = _o->program_timeout_ms; 3741 auto _features = _o->features; 3742 auto _env_flags = _o->env_flags; 3743 auto _sandbox_arg = _o->sandbox_arg; 3744 return rpc::CreateSnapshotHandshake( 3745 _fbb, 3746 _cover_edges, 3747 _kernel_64_bit, 3748 _slowdown, 3749 _syscall_timeout_ms, 3750 _program_timeout_ms, 3751 _features, 3752 _env_flags, 3753 _sandbox_arg); 3754 } 3755 3756 inline SnapshotRequestT *SnapshotRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { 3757 auto _o = std::unique_ptr<SnapshotRequestT>(new SnapshotRequestT()); 3758 UnPackTo(_o.get(), _resolver); 3759 return _o.release(); 3760 } 3761 3762 inline void SnapshotRequest::UnPackTo(SnapshotRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { 3763 (void)_o; 3764 (void)_resolver; 3765 { auto _e = exec_flags(); _o->exec_flags = _e; } 3766 { auto _e = num_calls(); _o->num_calls = _e; } 3767 { auto _e = all_call_signal(); _o->all_call_signal = _e; } 3768 { auto _e = all_extra_signal(); _o->all_extra_signal = _e; } 3769 { auto _e = prog_data(); if (_e) { _o->prog_data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->prog_data.begin()); } } 3770 } 3771 3772 inline ::flatbuffers::Offset<SnapshotRequest> SnapshotRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3773 return CreateSnapshotRequest(_fbb, _o, _rehasher); 3774 } 3775 3776 inline ::flatbuffers::Offset<SnapshotRequest> CreateSnapshotRequest(::flatbuffers::FlatBufferBuilder &_fbb, const SnapshotRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { 3777 (void)_rehasher; 3778 (void)_o; 3779 struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const SnapshotRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; 3780 auto _exec_flags = _o->exec_flags; 3781 auto _num_calls = _o->num_calls; 3782 auto _all_call_signal = _o->all_call_signal; 3783 auto _all_extra_signal = _o->all_extra_signal; 3784 auto _prog_data = _o->prog_data.size() ? _fbb.CreateVector(_o->prog_data) : 0; 3785 return rpc::CreateSnapshotRequest( 3786 _fbb, 3787 _exec_flags, 3788 _num_calls, 3789 _all_call_signal, 3790 _all_extra_signal, 3791 _prog_data); 3792 } 3793 3794 inline bool VerifyHostMessagesRaw(::flatbuffers::Verifier &verifier, const void *obj, HostMessagesRaw type) { 3795 switch (type) { 3796 case HostMessagesRaw::NONE: { 3797 return true; 3798 } 3799 case HostMessagesRaw::ExecRequest: { 3800 auto ptr = reinterpret_cast<const rpc::ExecRequestRaw *>(obj); 3801 return verifier.VerifyTable(ptr); 3802 } 3803 case HostMessagesRaw::SignalUpdate: { 3804 auto ptr = reinterpret_cast<const rpc::SignalUpdateRaw *>(obj); 3805 return verifier.VerifyTable(ptr); 3806 } 3807 case HostMessagesRaw::CorpusTriaged: { 3808 auto ptr = reinterpret_cast<const rpc::CorpusTriagedRaw *>(obj); 3809 return verifier.VerifyTable(ptr); 3810 } 3811 case HostMessagesRaw::StateRequest: { 3812 auto ptr = reinterpret_cast<const rpc::StateRequestRaw *>(obj); 3813 return verifier.VerifyTable(ptr); 3814 } 3815 default: return true; 3816 } 3817 } 3818 3819 inline bool VerifyHostMessagesRawVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<HostMessagesRaw> *types) { 3820 if (!values || !types) return !values && !types; 3821 if (values->size() != types->size()) return false; 3822 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 3823 if (!VerifyHostMessagesRaw( 3824 verifier, values->Get(i), types->GetEnum<HostMessagesRaw>(i))) { 3825 return false; 3826 } 3827 } 3828 return true; 3829 } 3830 3831 inline void *HostMessagesRawUnion::UnPack(const void *obj, HostMessagesRaw type, const ::flatbuffers::resolver_function_t *resolver) { 3832 (void)resolver; 3833 switch (type) { 3834 case HostMessagesRaw::ExecRequest: { 3835 auto ptr = reinterpret_cast<const rpc::ExecRequestRaw *>(obj); 3836 return ptr->UnPack(resolver); 3837 } 3838 case HostMessagesRaw::SignalUpdate: { 3839 auto ptr = reinterpret_cast<const rpc::SignalUpdateRaw *>(obj); 3840 return ptr->UnPack(resolver); 3841 } 3842 case HostMessagesRaw::CorpusTriaged: { 3843 auto ptr = reinterpret_cast<const rpc::CorpusTriagedRaw *>(obj); 3844 return ptr->UnPack(resolver); 3845 } 3846 case HostMessagesRaw::StateRequest: { 3847 auto ptr = reinterpret_cast<const rpc::StateRequestRaw *>(obj); 3848 return ptr->UnPack(resolver); 3849 } 3850 default: return nullptr; 3851 } 3852 } 3853 3854 inline ::flatbuffers::Offset<void> HostMessagesRawUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { 3855 (void)_rehasher; 3856 switch (type) { 3857 case HostMessagesRaw::ExecRequest: { 3858 auto ptr = reinterpret_cast<const rpc::ExecRequestRawT *>(value); 3859 return CreateExecRequestRaw(_fbb, ptr, _rehasher).Union(); 3860 } 3861 case HostMessagesRaw::SignalUpdate: { 3862 auto ptr = reinterpret_cast<const rpc::SignalUpdateRawT *>(value); 3863 return CreateSignalUpdateRaw(_fbb, ptr, _rehasher).Union(); 3864 } 3865 case HostMessagesRaw::CorpusTriaged: { 3866 auto ptr = reinterpret_cast<const rpc::CorpusTriagedRawT *>(value); 3867 return CreateCorpusTriagedRaw(_fbb, ptr, _rehasher).Union(); 3868 } 3869 case HostMessagesRaw::StateRequest: { 3870 auto ptr = reinterpret_cast<const rpc::StateRequestRawT *>(value); 3871 return CreateStateRequestRaw(_fbb, ptr, _rehasher).Union(); 3872 } 3873 default: return 0; 3874 } 3875 } 3876 3877 inline HostMessagesRawUnion::HostMessagesRawUnion(const HostMessagesRawUnion &u) : type(u.type), value(nullptr) { 3878 switch (type) { 3879 case HostMessagesRaw::ExecRequest: { 3880 value = new rpc::ExecRequestRawT(*reinterpret_cast<rpc::ExecRequestRawT *>(u.value)); 3881 break; 3882 } 3883 case HostMessagesRaw::SignalUpdate: { 3884 value = new rpc::SignalUpdateRawT(*reinterpret_cast<rpc::SignalUpdateRawT *>(u.value)); 3885 break; 3886 } 3887 case HostMessagesRaw::CorpusTriaged: { 3888 value = new rpc::CorpusTriagedRawT(*reinterpret_cast<rpc::CorpusTriagedRawT *>(u.value)); 3889 break; 3890 } 3891 case HostMessagesRaw::StateRequest: { 3892 value = new rpc::StateRequestRawT(*reinterpret_cast<rpc::StateRequestRawT *>(u.value)); 3893 break; 3894 } 3895 default: 3896 break; 3897 } 3898 } 3899 3900 inline void HostMessagesRawUnion::Reset() { 3901 switch (type) { 3902 case HostMessagesRaw::ExecRequest: { 3903 auto ptr = reinterpret_cast<rpc::ExecRequestRawT *>(value); 3904 delete ptr; 3905 break; 3906 } 3907 case HostMessagesRaw::SignalUpdate: { 3908 auto ptr = reinterpret_cast<rpc::SignalUpdateRawT *>(value); 3909 delete ptr; 3910 break; 3911 } 3912 case HostMessagesRaw::CorpusTriaged: { 3913 auto ptr = reinterpret_cast<rpc::CorpusTriagedRawT *>(value); 3914 delete ptr; 3915 break; 3916 } 3917 case HostMessagesRaw::StateRequest: { 3918 auto ptr = reinterpret_cast<rpc::StateRequestRawT *>(value); 3919 delete ptr; 3920 break; 3921 } 3922 default: break; 3923 } 3924 value = nullptr; 3925 type = HostMessagesRaw::NONE; 3926 } 3927 3928 inline bool VerifyExecutorMessagesRaw(::flatbuffers::Verifier &verifier, const void *obj, ExecutorMessagesRaw type) { 3929 switch (type) { 3930 case ExecutorMessagesRaw::NONE: { 3931 return true; 3932 } 3933 case ExecutorMessagesRaw::ExecResult: { 3934 auto ptr = reinterpret_cast<const rpc::ExecResultRaw *>(obj); 3935 return verifier.VerifyTable(ptr); 3936 } 3937 case ExecutorMessagesRaw::Executing: { 3938 auto ptr = reinterpret_cast<const rpc::ExecutingMessageRaw *>(obj); 3939 return verifier.VerifyTable(ptr); 3940 } 3941 case ExecutorMessagesRaw::State: { 3942 auto ptr = reinterpret_cast<const rpc::StateResultRaw *>(obj); 3943 return verifier.VerifyTable(ptr); 3944 } 3945 default: return true; 3946 } 3947 } 3948 3949 inline bool VerifyExecutorMessagesRawVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<ExecutorMessagesRaw> *types) { 3950 if (!values || !types) return !values && !types; 3951 if (values->size() != types->size()) return false; 3952 for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 3953 if (!VerifyExecutorMessagesRaw( 3954 verifier, values->Get(i), types->GetEnum<ExecutorMessagesRaw>(i))) { 3955 return false; 3956 } 3957 } 3958 return true; 3959 } 3960 3961 inline void *ExecutorMessagesRawUnion::UnPack(const void *obj, ExecutorMessagesRaw type, const ::flatbuffers::resolver_function_t *resolver) { 3962 (void)resolver; 3963 switch (type) { 3964 case ExecutorMessagesRaw::ExecResult: { 3965 auto ptr = reinterpret_cast<const rpc::ExecResultRaw *>(obj); 3966 return ptr->UnPack(resolver); 3967 } 3968 case ExecutorMessagesRaw::Executing: { 3969 auto ptr = reinterpret_cast<const rpc::ExecutingMessageRaw *>(obj); 3970 return ptr->UnPack(resolver); 3971 } 3972 case ExecutorMessagesRaw::State: { 3973 auto ptr = reinterpret_cast<const rpc::StateResultRaw *>(obj); 3974 return ptr->UnPack(resolver); 3975 } 3976 default: return nullptr; 3977 } 3978 } 3979 3980 inline ::flatbuffers::Offset<void> ExecutorMessagesRawUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { 3981 (void)_rehasher; 3982 switch (type) { 3983 case ExecutorMessagesRaw::ExecResult: { 3984 auto ptr = reinterpret_cast<const rpc::ExecResultRawT *>(value); 3985 return CreateExecResultRaw(_fbb, ptr, _rehasher).Union(); 3986 } 3987 case ExecutorMessagesRaw::Executing: { 3988 auto ptr = reinterpret_cast<const rpc::ExecutingMessageRawT *>(value); 3989 return CreateExecutingMessageRaw(_fbb, ptr, _rehasher).Union(); 3990 } 3991 case ExecutorMessagesRaw::State: { 3992 auto ptr = reinterpret_cast<const rpc::StateResultRawT *>(value); 3993 return CreateStateResultRaw(_fbb, ptr, _rehasher).Union(); 3994 } 3995 default: return 0; 3996 } 3997 } 3998 3999 inline ExecutorMessagesRawUnion::ExecutorMessagesRawUnion(const ExecutorMessagesRawUnion &u) : type(u.type), value(nullptr) { 4000 switch (type) { 4001 case ExecutorMessagesRaw::ExecResult: { 4002 value = new rpc::ExecResultRawT(*reinterpret_cast<rpc::ExecResultRawT *>(u.value)); 4003 break; 4004 } 4005 case ExecutorMessagesRaw::Executing: { 4006 value = new rpc::ExecutingMessageRawT(*reinterpret_cast<rpc::ExecutingMessageRawT *>(u.value)); 4007 break; 4008 } 4009 case ExecutorMessagesRaw::State: { 4010 value = new rpc::StateResultRawT(*reinterpret_cast<rpc::StateResultRawT *>(u.value)); 4011 break; 4012 } 4013 default: 4014 break; 4015 } 4016 } 4017 4018 inline void ExecutorMessagesRawUnion::Reset() { 4019 switch (type) { 4020 case ExecutorMessagesRaw::ExecResult: { 4021 auto ptr = reinterpret_cast<rpc::ExecResultRawT *>(value); 4022 delete ptr; 4023 break; 4024 } 4025 case ExecutorMessagesRaw::Executing: { 4026 auto ptr = reinterpret_cast<rpc::ExecutingMessageRawT *>(value); 4027 delete ptr; 4028 break; 4029 } 4030 case ExecutorMessagesRaw::State: { 4031 auto ptr = reinterpret_cast<rpc::StateResultRawT *>(value); 4032 delete ptr; 4033 break; 4034 } 4035 default: break; 4036 } 4037 value = nullptr; 4038 type = ExecutorMessagesRaw::NONE; 4039 } 4040 4041 } // namespace rpc 4042 4043 #endif // FLATBUFFERS_GENERATED_FLATRPC_RPC_H_