1 // automatically generated by the FlatBuffers compiler, do not modify 2 3 4 #ifndef FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ 5 #define FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ 6 7 #include "flatbuffers/flatbuffers.h" 8 9 namespace chre { 10 namespace fbs { 11 12 struct NanoappMessage; 13 struct NanoappMessageT; 14 15 struct HubInfoRequest; 16 struct HubInfoRequestT; 17 18 struct HubInfoResponse; 19 struct HubInfoResponseT; 20 21 struct NanoappListRequest; 22 struct NanoappListRequestT; 23 24 struct NanoappListEntry; 25 struct NanoappListEntryT; 26 27 struct NanoappListResponse; 28 struct NanoappListResponseT; 29 30 struct LoadNanoappRequest; 31 struct LoadNanoappRequestT; 32 33 struct LoadNanoappResponse; 34 struct LoadNanoappResponseT; 35 36 struct HostAddress; 37 38 struct MessageContainer; 39 struct MessageContainerT; 40 41 /// A union that joins together all possible messages. Note that in FlatBuffers, 42 /// unions have an implicit type 43 enum class ChreMessage : uint8_t { 44 NONE = 0, 45 NanoappMessage = 1, 46 HubInfoRequest = 2, 47 HubInfoResponse = 3, 48 NanoappListRequest = 4, 49 NanoappListResponse = 5, 50 LoadNanoappRequest = 6, 51 LoadNanoappResponse = 7, 52 MIN = NONE, 53 MAX = LoadNanoappResponse 54 }; 55 56 inline const char **EnumNamesChreMessage() { 57 static const char *names[] = { 58 "NONE", 59 "NanoappMessage", 60 "HubInfoRequest", 61 "HubInfoResponse", 62 "NanoappListRequest", 63 "NanoappListResponse", 64 "LoadNanoappRequest", 65 "LoadNanoappResponse", 66 nullptr 67 }; 68 return names; 69 } 70 71 inline const char *EnumNameChreMessage(ChreMessage e) { 72 const size_t index = static_cast<int>(e); 73 return EnumNamesChreMessage()[index]; 74 } 75 76 template<typename T> struct ChreMessageTraits { 77 static const ChreMessage enum_value = ChreMessage::NONE; 78 }; 79 80 template<> struct ChreMessageTraits<NanoappMessage> { 81 static const ChreMessage enum_value = ChreMessage::NanoappMessage; 82 }; 83 84 template<> struct ChreMessageTraits<HubInfoRequest> { 85 static const ChreMessage enum_value = ChreMessage::HubInfoRequest; 86 }; 87 88 template<> struct ChreMessageTraits<HubInfoResponse> { 89 static const ChreMessage enum_value = ChreMessage::HubInfoResponse; 90 }; 91 92 template<> struct ChreMessageTraits<NanoappListRequest> { 93 static const ChreMessage enum_value = ChreMessage::NanoappListRequest; 94 }; 95 96 template<> struct ChreMessageTraits<NanoappListResponse> { 97 static const ChreMessage enum_value = ChreMessage::NanoappListResponse; 98 }; 99 100 template<> struct ChreMessageTraits<LoadNanoappRequest> { 101 static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest; 102 }; 103 104 template<> struct ChreMessageTraits<LoadNanoappResponse> { 105 static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse; 106 }; 107 108 struct ChreMessageUnion { 109 ChreMessage type; 110 flatbuffers::NativeTable *table; 111 112 ChreMessageUnion() : type(ChreMessage::NONE), table(nullptr) {} 113 ChreMessageUnion(ChreMessageUnion&& u): 114 type(std::move(u.type)), table(std::move(u.table)) {} 115 ChreMessageUnion(const ChreMessageUnion &); 116 ChreMessageUnion &operator=(const ChreMessageUnion &); 117 ~ChreMessageUnion() { Reset(); } 118 119 void Reset(); 120 121 template <typename T> 122 void Set(T&& value) { 123 Reset(); 124 type = ChreMessageTraits<typename T::TableType>::enum_value; 125 if (type != ChreMessage::NONE) { 126 table = new T(std::forward<T>(value)); 127 } 128 } 129 130 static flatbuffers::NativeTable *UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver); 131 flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const; 132 133 NanoappMessageT *AsNanoappMessage() { 134 return type == ChreMessage::NanoappMessage ? 135 reinterpret_cast<NanoappMessageT *>(table) : nullptr; 136 } 137 HubInfoRequestT *AsHubInfoRequest() { 138 return type == ChreMessage::HubInfoRequest ? 139 reinterpret_cast<HubInfoRequestT *>(table) : nullptr; 140 } 141 HubInfoResponseT *AsHubInfoResponse() { 142 return type == ChreMessage::HubInfoResponse ? 143 reinterpret_cast<HubInfoResponseT *>(table) : nullptr; 144 } 145 NanoappListRequestT *AsNanoappListRequest() { 146 return type == ChreMessage::NanoappListRequest ? 147 reinterpret_cast<NanoappListRequestT *>(table) : nullptr; 148 } 149 NanoappListResponseT *AsNanoappListResponse() { 150 return type == ChreMessage::NanoappListResponse ? 151 reinterpret_cast<NanoappListResponseT *>(table) : nullptr; 152 } 153 LoadNanoappRequestT *AsLoadNanoappRequest() { 154 return type == ChreMessage::LoadNanoappRequest ? 155 reinterpret_cast<LoadNanoappRequestT *>(table) : nullptr; 156 } 157 LoadNanoappResponseT *AsLoadNanoappResponse() { 158 return type == ChreMessage::LoadNanoappResponse ? 159 reinterpret_cast<LoadNanoappResponseT *>(table) : nullptr; 160 } 161 }; 162 163 bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type); 164 bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); 165 166 MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS { 167 private: 168 uint16_t client_id_; 169 170 public: 171 HostAddress() { 172 memset(this, 0, sizeof(HostAddress)); 173 } 174 HostAddress(const HostAddress &_o) { 175 memcpy(this, &_o, sizeof(HostAddress)); 176 } 177 HostAddress(uint16_t _client_id) 178 : client_id_(flatbuffers::EndianScalar(_client_id)) { 179 } 180 uint16_t client_id() const { 181 return flatbuffers::EndianScalar(client_id_); 182 } 183 void mutate_client_id(uint16_t _client_id) { 184 flatbuffers::WriteScalar(&client_id_, _client_id); 185 } 186 }; 187 STRUCT_END(HostAddress, 2); 188 189 struct NanoappMessageT : public flatbuffers::NativeTable { 190 typedef NanoappMessage TableType; 191 uint64_t app_id; 192 uint32_t message_type; 193 uint16_t host_endpoint; 194 std::vector<uint8_t> message; 195 NanoappMessageT() 196 : app_id(0), 197 message_type(0), 198 host_endpoint(65534) { 199 } 200 }; 201 202 /// Represents a message sent to/from a nanoapp from/to a client on the host 203 struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 204 typedef NanoappMessageT NativeTableType; 205 enum { 206 VT_APP_ID = 4, 207 VT_MESSAGE_TYPE = 6, 208 VT_HOST_ENDPOINT = 8, 209 VT_MESSAGE = 10 210 }; 211 uint64_t app_id() const { 212 return GetField<uint64_t>(VT_APP_ID, 0); 213 } 214 bool mutate_app_id(uint64_t _app_id) { 215 return SetField(VT_APP_ID, _app_id); 216 } 217 uint32_t message_type() const { 218 return GetField<uint32_t>(VT_MESSAGE_TYPE, 0); 219 } 220 bool mutate_message_type(uint32_t _message_type) { 221 return SetField(VT_MESSAGE_TYPE, _message_type); 222 } 223 /// Identifies the host-side endpoint on the host that sent or should receive 224 /// this message. The default value is a special value defined in the HAL and 225 /// elsewhere that indicates that the endpoint is unspecified. 226 uint16_t host_endpoint() const { 227 return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534); 228 } 229 bool mutate_host_endpoint(uint16_t _host_endpoint) { 230 return SetField(VT_HOST_ENDPOINT, _host_endpoint); 231 } 232 /// Vector containing arbitrary application-specific message data 233 const flatbuffers::Vector<uint8_t> *message() const { 234 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE); 235 } 236 flatbuffers::Vector<uint8_t> *mutable_message() { 237 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_MESSAGE); 238 } 239 bool Verify(flatbuffers::Verifier &verifier) const { 240 return VerifyTableStart(verifier) && 241 VerifyField<uint64_t>(verifier, VT_APP_ID) && 242 VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) && 243 VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) && 244 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) && 245 verifier.Verify(message()) && 246 verifier.EndTable(); 247 } 248 NanoappMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 249 void UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 250 static flatbuffers::Offset<NanoappMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 251 }; 252 253 struct NanoappMessageBuilder { 254 flatbuffers::FlatBufferBuilder &fbb_; 255 flatbuffers::uoffset_t start_; 256 void add_app_id(uint64_t app_id) { 257 fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0); 258 } 259 void add_message_type(uint32_t message_type) { 260 fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0); 261 } 262 void add_host_endpoint(uint16_t host_endpoint) { 263 fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534); 264 } 265 void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) { 266 fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message); 267 } 268 NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb) 269 : fbb_(_fbb) { 270 start_ = fbb_.StartTable(); 271 } 272 NanoappMessageBuilder &operator=(const NanoappMessageBuilder &); 273 flatbuffers::Offset<NanoappMessage> Finish() { 274 const auto end = fbb_.EndTable(start_, 4); 275 auto o = flatbuffers::Offset<NanoappMessage>(end); 276 fbb_.Required(o, NanoappMessage::VT_MESSAGE); 277 return o; 278 } 279 }; 280 281 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage( 282 flatbuffers::FlatBufferBuilder &_fbb, 283 uint64_t app_id = 0, 284 uint32_t message_type = 0, 285 uint16_t host_endpoint = 65534, 286 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0) { 287 NanoappMessageBuilder builder_(_fbb); 288 builder_.add_app_id(app_id); 289 builder_.add_message(message); 290 builder_.add_message_type(message_type); 291 builder_.add_host_endpoint(host_endpoint); 292 return builder_.Finish(); 293 } 294 295 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect( 296 flatbuffers::FlatBufferBuilder &_fbb, 297 uint64_t app_id = 0, 298 uint32_t message_type = 0, 299 uint16_t host_endpoint = 65534, 300 const std::vector<uint8_t> *message = nullptr) { 301 return chre::fbs::CreateNanoappMessage( 302 _fbb, 303 app_id, 304 message_type, 305 host_endpoint, 306 message ? _fbb.CreateVector<uint8_t>(*message) : 0); 307 } 308 309 flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 310 311 struct HubInfoRequestT : public flatbuffers::NativeTable { 312 typedef HubInfoRequest TableType; 313 HubInfoRequestT() { 314 } 315 }; 316 317 struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 318 typedef HubInfoRequestT NativeTableType; 319 bool Verify(flatbuffers::Verifier &verifier) const { 320 return VerifyTableStart(verifier) && 321 verifier.EndTable(); 322 } 323 HubInfoRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 324 void UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 325 static flatbuffers::Offset<HubInfoRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 326 }; 327 328 struct HubInfoRequestBuilder { 329 flatbuffers::FlatBufferBuilder &fbb_; 330 flatbuffers::uoffset_t start_; 331 HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 332 : fbb_(_fbb) { 333 start_ = fbb_.StartTable(); 334 } 335 HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &); 336 flatbuffers::Offset<HubInfoRequest> Finish() { 337 const auto end = fbb_.EndTable(start_, 0); 338 auto o = flatbuffers::Offset<HubInfoRequest>(end); 339 return o; 340 } 341 }; 342 343 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest( 344 flatbuffers::FlatBufferBuilder &_fbb) { 345 HubInfoRequestBuilder builder_(_fbb); 346 return builder_.Finish(); 347 } 348 349 flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 350 351 struct HubInfoResponseT : public flatbuffers::NativeTable { 352 typedef HubInfoResponse TableType; 353 std::vector<int8_t> name; 354 std::vector<int8_t> vendor; 355 std::vector<int8_t> toolchain; 356 uint32_t platform_version; 357 uint32_t toolchain_version; 358 float peak_mips; 359 float stopped_power; 360 float sleep_power; 361 float peak_power; 362 uint32_t max_msg_len; 363 uint64_t platform_id; 364 uint32_t chre_platform_version; 365 HubInfoResponseT() 366 : platform_version(0), 367 toolchain_version(0), 368 peak_mips(0.0f), 369 stopped_power(0.0f), 370 sleep_power(0.0f), 371 peak_power(0.0f), 372 max_msg_len(0), 373 platform_id(0), 374 chre_platform_version(0) { 375 } 376 }; 377 378 struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 379 typedef HubInfoResponseT NativeTableType; 380 enum { 381 VT_NAME = 4, 382 VT_VENDOR = 6, 383 VT_TOOLCHAIN = 8, 384 VT_PLATFORM_VERSION = 10, 385 VT_TOOLCHAIN_VERSION = 12, 386 VT_PEAK_MIPS = 14, 387 VT_STOPPED_POWER = 16, 388 VT_SLEEP_POWER = 18, 389 VT_PEAK_POWER = 20, 390 VT_MAX_MSG_LEN = 22, 391 VT_PLATFORM_ID = 24, 392 VT_CHRE_PLATFORM_VERSION = 26 393 }; 394 /// The name of the hub. Nominally a UTF-8 string, but note that we're not 395 /// using the built-in "string" data type from FlatBuffers here, because the 396 /// generated C++ uses std::string which is not well-supported in CHRE. This 397 /// applies for vendor and toolchain as well. 398 const flatbuffers::Vector<int8_t> *name() const { 399 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME); 400 } 401 flatbuffers::Vector<int8_t> *mutable_name() { 402 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME); 403 } 404 const flatbuffers::Vector<int8_t> *vendor() const { 405 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR); 406 } 407 flatbuffers::Vector<int8_t> *mutable_vendor() { 408 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VENDOR); 409 } 410 const flatbuffers::Vector<int8_t> *toolchain() const { 411 return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN); 412 } 413 flatbuffers::Vector<int8_t> *mutable_toolchain() { 414 return GetPointer<flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN); 415 } 416 /// Legacy platform version reported in the HAL; semantics not strictly 417 /// defined 418 uint32_t platform_version() const { 419 return GetField<uint32_t>(VT_PLATFORM_VERSION, 0); 420 } 421 bool mutate_platform_version(uint32_t _platform_version) { 422 return SetField(VT_PLATFORM_VERSION, _platform_version); 423 } 424 /// Toolchain version reported in the HAL; semantics not strictly defined 425 uint32_t toolchain_version() const { 426 return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0); 427 } 428 bool mutate_toolchain_version(uint32_t _toolchain_version) { 429 return SetField(VT_TOOLCHAIN_VERSION, _toolchain_version); 430 } 431 float peak_mips() const { 432 return GetField<float>(VT_PEAK_MIPS, 0.0f); 433 } 434 bool mutate_peak_mips(float _peak_mips) { 435 return SetField(VT_PEAK_MIPS, _peak_mips); 436 } 437 float stopped_power() const { 438 return GetField<float>(VT_STOPPED_POWER, 0.0f); 439 } 440 bool mutate_stopped_power(float _stopped_power) { 441 return SetField(VT_STOPPED_POWER, _stopped_power); 442 } 443 float sleep_power() const { 444 return GetField<float>(VT_SLEEP_POWER, 0.0f); 445 } 446 bool mutate_sleep_power(float _sleep_power) { 447 return SetField(VT_SLEEP_POWER, _sleep_power); 448 } 449 float peak_power() const { 450 return GetField<float>(VT_PEAK_POWER, 0.0f); 451 } 452 bool mutate_peak_power(float _peak_power) { 453 return SetField(VT_PEAK_POWER, _peak_power); 454 } 455 /// Maximum size message that can be sent to a nanoapp 456 uint32_t max_msg_len() const { 457 return GetField<uint32_t>(VT_MAX_MSG_LEN, 0); 458 } 459 bool mutate_max_msg_len(uint32_t _max_msg_len) { 460 return SetField(VT_MAX_MSG_LEN, _max_msg_len); 461 } 462 /// @see chreGetPlatformId() 463 uint64_t platform_id() const { 464 return GetField<uint64_t>(VT_PLATFORM_ID, 0); 465 } 466 bool mutate_platform_id(uint64_t _platform_id) { 467 return SetField(VT_PLATFORM_ID, _platform_id); 468 } 469 /// @see chreGetVersion() 470 uint32_t chre_platform_version() const { 471 return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0); 472 } 473 bool mutate_chre_platform_version(uint32_t _chre_platform_version) { 474 return SetField(VT_CHRE_PLATFORM_VERSION, _chre_platform_version); 475 } 476 bool Verify(flatbuffers::Verifier &verifier) const { 477 return VerifyTableStart(verifier) && 478 VerifyField<flatbuffers::uoffset_t>(verifier, VT_NAME) && 479 verifier.Verify(name()) && 480 VerifyField<flatbuffers::uoffset_t>(verifier, VT_VENDOR) && 481 verifier.Verify(vendor()) && 482 VerifyField<flatbuffers::uoffset_t>(verifier, VT_TOOLCHAIN) && 483 verifier.Verify(toolchain()) && 484 VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) && 485 VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) && 486 VerifyField<float>(verifier, VT_PEAK_MIPS) && 487 VerifyField<float>(verifier, VT_STOPPED_POWER) && 488 VerifyField<float>(verifier, VT_SLEEP_POWER) && 489 VerifyField<float>(verifier, VT_PEAK_POWER) && 490 VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) && 491 VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) && 492 VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) && 493 verifier.EndTable(); 494 } 495 HubInfoResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 496 void UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 497 static flatbuffers::Offset<HubInfoResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 498 }; 499 500 struct HubInfoResponseBuilder { 501 flatbuffers::FlatBufferBuilder &fbb_; 502 flatbuffers::uoffset_t start_; 503 void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) { 504 fbb_.AddOffset(HubInfoResponse::VT_NAME, name); 505 } 506 void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) { 507 fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor); 508 } 509 void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) { 510 fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain); 511 } 512 void add_platform_version(uint32_t platform_version) { 513 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0); 514 } 515 void add_toolchain_version(uint32_t toolchain_version) { 516 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0); 517 } 518 void add_peak_mips(float peak_mips) { 519 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f); 520 } 521 void add_stopped_power(float stopped_power) { 522 fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f); 523 } 524 void add_sleep_power(float sleep_power) { 525 fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f); 526 } 527 void add_peak_power(float peak_power) { 528 fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f); 529 } 530 void add_max_msg_len(uint32_t max_msg_len) { 531 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0); 532 } 533 void add_platform_id(uint64_t platform_id) { 534 fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0); 535 } 536 void add_chre_platform_version(uint32_t chre_platform_version) { 537 fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0); 538 } 539 HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 540 : fbb_(_fbb) { 541 start_ = fbb_.StartTable(); 542 } 543 HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &); 544 flatbuffers::Offset<HubInfoResponse> Finish() { 545 const auto end = fbb_.EndTable(start_, 12); 546 auto o = flatbuffers::Offset<HubInfoResponse>(end); 547 return o; 548 } 549 }; 550 551 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse( 552 flatbuffers::FlatBufferBuilder &_fbb, 553 flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0, 554 flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0, 555 flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0, 556 uint32_t platform_version = 0, 557 uint32_t toolchain_version = 0, 558 float peak_mips = 0.0f, 559 float stopped_power = 0.0f, 560 float sleep_power = 0.0f, 561 float peak_power = 0.0f, 562 uint32_t max_msg_len = 0, 563 uint64_t platform_id = 0, 564 uint32_t chre_platform_version = 0) { 565 HubInfoResponseBuilder builder_(_fbb); 566 builder_.add_platform_id(platform_id); 567 builder_.add_chre_platform_version(chre_platform_version); 568 builder_.add_max_msg_len(max_msg_len); 569 builder_.add_peak_power(peak_power); 570 builder_.add_sleep_power(sleep_power); 571 builder_.add_stopped_power(stopped_power); 572 builder_.add_peak_mips(peak_mips); 573 builder_.add_toolchain_version(toolchain_version); 574 builder_.add_platform_version(platform_version); 575 builder_.add_toolchain(toolchain); 576 builder_.add_vendor(vendor); 577 builder_.add_name(name); 578 return builder_.Finish(); 579 } 580 581 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect( 582 flatbuffers::FlatBufferBuilder &_fbb, 583 const std::vector<int8_t> *name = nullptr, 584 const std::vector<int8_t> *vendor = nullptr, 585 const std::vector<int8_t> *toolchain = nullptr, 586 uint32_t platform_version = 0, 587 uint32_t toolchain_version = 0, 588 float peak_mips = 0.0f, 589 float stopped_power = 0.0f, 590 float sleep_power = 0.0f, 591 float peak_power = 0.0f, 592 uint32_t max_msg_len = 0, 593 uint64_t platform_id = 0, 594 uint32_t chre_platform_version = 0) { 595 return chre::fbs::CreateHubInfoResponse( 596 _fbb, 597 name ? _fbb.CreateVector<int8_t>(*name) : 0, 598 vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0, 599 toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0, 600 platform_version, 601 toolchain_version, 602 peak_mips, 603 stopped_power, 604 sleep_power, 605 peak_power, 606 max_msg_len, 607 platform_id, 608 chre_platform_version); 609 } 610 611 flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 612 613 struct NanoappListRequestT : public flatbuffers::NativeTable { 614 typedef NanoappListRequest TableType; 615 NanoappListRequestT() { 616 } 617 }; 618 619 struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 620 typedef NanoappListRequestT NativeTableType; 621 bool Verify(flatbuffers::Verifier &verifier) const { 622 return VerifyTableStart(verifier) && 623 verifier.EndTable(); 624 } 625 NanoappListRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 626 void UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 627 static flatbuffers::Offset<NanoappListRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 628 }; 629 630 struct NanoappListRequestBuilder { 631 flatbuffers::FlatBufferBuilder &fbb_; 632 flatbuffers::uoffset_t start_; 633 NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 634 : fbb_(_fbb) { 635 start_ = fbb_.StartTable(); 636 } 637 NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &); 638 flatbuffers::Offset<NanoappListRequest> Finish() { 639 const auto end = fbb_.EndTable(start_, 0); 640 auto o = flatbuffers::Offset<NanoappListRequest>(end); 641 return o; 642 } 643 }; 644 645 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest( 646 flatbuffers::FlatBufferBuilder &_fbb) { 647 NanoappListRequestBuilder builder_(_fbb); 648 return builder_.Finish(); 649 } 650 651 flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 652 653 struct NanoappListEntryT : public flatbuffers::NativeTable { 654 typedef NanoappListEntry TableType; 655 uint64_t app_id; 656 uint32_t version; 657 bool enabled; 658 bool is_system; 659 NanoappListEntryT() 660 : app_id(0), 661 version(0), 662 enabled(true), 663 is_system(false) { 664 } 665 }; 666 667 struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 668 typedef NanoappListEntryT NativeTableType; 669 enum { 670 VT_APP_ID = 4, 671 VT_VERSION = 6, 672 VT_ENABLED = 8, 673 VT_IS_SYSTEM = 10 674 }; 675 uint64_t app_id() const { 676 return GetField<uint64_t>(VT_APP_ID, 0); 677 } 678 bool mutate_app_id(uint64_t _app_id) { 679 return SetField(VT_APP_ID, _app_id); 680 } 681 uint32_t version() const { 682 return GetField<uint32_t>(VT_VERSION, 0); 683 } 684 bool mutate_version(uint32_t _version) { 685 return SetField(VT_VERSION, _version); 686 } 687 bool enabled() const { 688 return GetField<uint8_t>(VT_ENABLED, 1) != 0; 689 } 690 bool mutate_enabled(bool _enabled) { 691 return SetField(VT_ENABLED, static_cast<uint8_t>(_enabled)); 692 } 693 /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should 694 /// not show up in the list of nanoapps in the context hub HAL. System 695 /// nanoapps are typically used to leverage CHRE for some device functionality 696 /// and do not interact via the context hub HAL. 697 bool is_system() const { 698 return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0; 699 } 700 bool mutate_is_system(bool _is_system) { 701 return SetField(VT_IS_SYSTEM, static_cast<uint8_t>(_is_system)); 702 } 703 bool Verify(flatbuffers::Verifier &verifier) const { 704 return VerifyTableStart(verifier) && 705 VerifyField<uint64_t>(verifier, VT_APP_ID) && 706 VerifyField<uint32_t>(verifier, VT_VERSION) && 707 VerifyField<uint8_t>(verifier, VT_ENABLED) && 708 VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) && 709 verifier.EndTable(); 710 } 711 NanoappListEntryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 712 void UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 713 static flatbuffers::Offset<NanoappListEntry> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 714 }; 715 716 struct NanoappListEntryBuilder { 717 flatbuffers::FlatBufferBuilder &fbb_; 718 flatbuffers::uoffset_t start_; 719 void add_app_id(uint64_t app_id) { 720 fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0); 721 } 722 void add_version(uint32_t version) { 723 fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0); 724 } 725 void add_enabled(bool enabled) { 726 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1); 727 } 728 void add_is_system(bool is_system) { 729 fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0); 730 } 731 NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb) 732 : fbb_(_fbb) { 733 start_ = fbb_.StartTable(); 734 } 735 NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &); 736 flatbuffers::Offset<NanoappListEntry> Finish() { 737 const auto end = fbb_.EndTable(start_, 4); 738 auto o = flatbuffers::Offset<NanoappListEntry>(end); 739 return o; 740 } 741 }; 742 743 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry( 744 flatbuffers::FlatBufferBuilder &_fbb, 745 uint64_t app_id = 0, 746 uint32_t version = 0, 747 bool enabled = true, 748 bool is_system = false) { 749 NanoappListEntryBuilder builder_(_fbb); 750 builder_.add_app_id(app_id); 751 builder_.add_version(version); 752 builder_.add_is_system(is_system); 753 builder_.add_enabled(enabled); 754 return builder_.Finish(); 755 } 756 757 flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 758 759 struct NanoappListResponseT : public flatbuffers::NativeTable { 760 typedef NanoappListResponse TableType; 761 std::vector<std::unique_ptr<NanoappListEntryT>> nanoapps; 762 NanoappListResponseT() { 763 } 764 }; 765 766 struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 767 typedef NanoappListResponseT NativeTableType; 768 enum { 769 VT_NANOAPPS = 4 770 }; 771 const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps() const { 772 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS); 773 } 774 flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *mutable_nanoapps() { 775 return GetPointer<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS); 776 } 777 bool Verify(flatbuffers::Verifier &verifier) const { 778 return VerifyTableStart(verifier) && 779 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NANOAPPS) && 780 verifier.Verify(nanoapps()) && 781 verifier.VerifyVectorOfTables(nanoapps()) && 782 verifier.EndTable(); 783 } 784 NanoappListResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 785 void UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 786 static flatbuffers::Offset<NanoappListResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 787 }; 788 789 struct NanoappListResponseBuilder { 790 flatbuffers::FlatBufferBuilder &fbb_; 791 flatbuffers::uoffset_t start_; 792 void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps) { 793 fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps); 794 } 795 NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 796 : fbb_(_fbb) { 797 start_ = fbb_.StartTable(); 798 } 799 NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &); 800 flatbuffers::Offset<NanoappListResponse> Finish() { 801 const auto end = fbb_.EndTable(start_, 1); 802 auto o = flatbuffers::Offset<NanoappListResponse>(end); 803 fbb_.Required(o, NanoappListResponse::VT_NANOAPPS); 804 return o; 805 } 806 }; 807 808 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse( 809 flatbuffers::FlatBufferBuilder &_fbb, 810 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps = 0) { 811 NanoappListResponseBuilder builder_(_fbb); 812 builder_.add_nanoapps(nanoapps); 813 return builder_.Finish(); 814 } 815 816 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect( 817 flatbuffers::FlatBufferBuilder &_fbb, 818 const std::vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps = nullptr) { 819 return chre::fbs::CreateNanoappListResponse( 820 _fbb, 821 nanoapps ? _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(*nanoapps) : 0); 822 } 823 824 flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 825 826 struct LoadNanoappRequestT : public flatbuffers::NativeTable { 827 typedef LoadNanoappRequest TableType; 828 uint32_t transaction_id; 829 uint64_t app_id; 830 uint32_t app_version; 831 uint32_t target_api_version; 832 std::vector<uint8_t> app_binary; 833 LoadNanoappRequestT() 834 : transaction_id(0), 835 app_id(0), 836 app_version(0), 837 target_api_version(0) { 838 } 839 }; 840 841 struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 842 typedef LoadNanoappRequestT NativeTableType; 843 enum { 844 VT_TRANSACTION_ID = 4, 845 VT_APP_ID = 6, 846 VT_APP_VERSION = 8, 847 VT_TARGET_API_VERSION = 10, 848 VT_APP_BINARY = 12 849 }; 850 uint32_t transaction_id() const { 851 return GetField<uint32_t>(VT_TRANSACTION_ID, 0); 852 } 853 bool mutate_transaction_id(uint32_t _transaction_id) { 854 return SetField(VT_TRANSACTION_ID, _transaction_id); 855 } 856 uint64_t app_id() const { 857 return GetField<uint64_t>(VT_APP_ID, 0); 858 } 859 bool mutate_app_id(uint64_t _app_id) { 860 return SetField(VT_APP_ID, _app_id); 861 } 862 uint32_t app_version() const { 863 return GetField<uint32_t>(VT_APP_VERSION, 0); 864 } 865 bool mutate_app_version(uint32_t _app_version) { 866 return SetField(VT_APP_VERSION, _app_version); 867 } 868 uint32_t target_api_version() const { 869 return GetField<uint32_t>(VT_TARGET_API_VERSION, 0); 870 } 871 bool mutate_target_api_version(uint32_t _target_api_version) { 872 return SetField(VT_TARGET_API_VERSION, _target_api_version); 873 } 874 const flatbuffers::Vector<uint8_t> *app_binary() const { 875 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY); 876 } 877 flatbuffers::Vector<uint8_t> *mutable_app_binary() { 878 return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY); 879 } 880 bool Verify(flatbuffers::Verifier &verifier) const { 881 return VerifyTableStart(verifier) && 882 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && 883 VerifyField<uint64_t>(verifier, VT_APP_ID) && 884 VerifyField<uint32_t>(verifier, VT_APP_VERSION) && 885 VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) && 886 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_APP_BINARY) && 887 verifier.Verify(app_binary()) && 888 verifier.EndTable(); 889 } 890 LoadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 891 void UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 892 static flatbuffers::Offset<LoadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 893 }; 894 895 struct LoadNanoappRequestBuilder { 896 flatbuffers::FlatBufferBuilder &fbb_; 897 flatbuffers::uoffset_t start_; 898 void add_transaction_id(uint32_t transaction_id) { 899 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0); 900 } 901 void add_app_id(uint64_t app_id) { 902 fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0); 903 } 904 void add_app_version(uint32_t app_version) { 905 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0); 906 } 907 void add_target_api_version(uint32_t target_api_version) { 908 fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0); 909 } 910 void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) { 911 fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary); 912 } 913 LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb) 914 : fbb_(_fbb) { 915 start_ = fbb_.StartTable(); 916 } 917 LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &); 918 flatbuffers::Offset<LoadNanoappRequest> Finish() { 919 const auto end = fbb_.EndTable(start_, 5); 920 auto o = flatbuffers::Offset<LoadNanoappRequest>(end); 921 fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY); 922 return o; 923 } 924 }; 925 926 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest( 927 flatbuffers::FlatBufferBuilder &_fbb, 928 uint32_t transaction_id = 0, 929 uint64_t app_id = 0, 930 uint32_t app_version = 0, 931 uint32_t target_api_version = 0, 932 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0) { 933 LoadNanoappRequestBuilder builder_(_fbb); 934 builder_.add_app_id(app_id); 935 builder_.add_app_binary(app_binary); 936 builder_.add_target_api_version(target_api_version); 937 builder_.add_app_version(app_version); 938 builder_.add_transaction_id(transaction_id); 939 return builder_.Finish(); 940 } 941 942 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect( 943 flatbuffers::FlatBufferBuilder &_fbb, 944 uint32_t transaction_id = 0, 945 uint64_t app_id = 0, 946 uint32_t app_version = 0, 947 uint32_t target_api_version = 0, 948 const std::vector<uint8_t> *app_binary = nullptr) { 949 return chre::fbs::CreateLoadNanoappRequest( 950 _fbb, 951 transaction_id, 952 app_id, 953 app_version, 954 target_api_version, 955 app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0); 956 } 957 958 flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 959 960 struct LoadNanoappResponseT : public flatbuffers::NativeTable { 961 typedef LoadNanoappResponse TableType; 962 uint32_t transaction_id; 963 bool success; 964 LoadNanoappResponseT() 965 : transaction_id(0), 966 success(false) { 967 } 968 }; 969 970 struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 971 typedef LoadNanoappResponseT NativeTableType; 972 enum { 973 VT_TRANSACTION_ID = 4, 974 VT_SUCCESS = 6 975 }; 976 uint32_t transaction_id() const { 977 return GetField<uint32_t>(VT_TRANSACTION_ID, 0); 978 } 979 bool mutate_transaction_id(uint32_t _transaction_id) { 980 return SetField(VT_TRANSACTION_ID, _transaction_id); 981 } 982 bool success() const { 983 return GetField<uint8_t>(VT_SUCCESS, 0) != 0; 984 } 985 bool mutate_success(bool _success) { 986 return SetField(VT_SUCCESS, static_cast<uint8_t>(_success)); 987 } 988 bool Verify(flatbuffers::Verifier &verifier) const { 989 return VerifyTableStart(verifier) && 990 VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) && 991 VerifyField<uint8_t>(verifier, VT_SUCCESS) && 992 verifier.EndTable(); 993 } 994 LoadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 995 void UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 996 static flatbuffers::Offset<LoadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 997 }; 998 999 struct LoadNanoappResponseBuilder { 1000 flatbuffers::FlatBufferBuilder &fbb_; 1001 flatbuffers::uoffset_t start_; 1002 void add_transaction_id(uint32_t transaction_id) { 1003 fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0); 1004 } 1005 void add_success(bool success) { 1006 fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0); 1007 } 1008 LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1009 : fbb_(_fbb) { 1010 start_ = fbb_.StartTable(); 1011 } 1012 LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &); 1013 flatbuffers::Offset<LoadNanoappResponse> Finish() { 1014 const auto end = fbb_.EndTable(start_, 2); 1015 auto o = flatbuffers::Offset<LoadNanoappResponse>(end); 1016 return o; 1017 } 1018 }; 1019 1020 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse( 1021 flatbuffers::FlatBufferBuilder &_fbb, 1022 uint32_t transaction_id = 0, 1023 bool success = false) { 1024 LoadNanoappResponseBuilder builder_(_fbb); 1025 builder_.add_transaction_id(transaction_id); 1026 builder_.add_success(success); 1027 return builder_.Finish(); 1028 } 1029 1030 flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1031 1032 struct MessageContainerT : public flatbuffers::NativeTable { 1033 typedef MessageContainer TableType; 1034 ChreMessageUnion message; 1035 std::unique_ptr<HostAddress> host_addr; 1036 MessageContainerT() { 1037 } 1038 }; 1039 1040 /// The top-level container that encapsulates all possible messages. Note that 1041 /// per FlatBuffers requirements, we can't use a union as the top-level structure 1042 /// (root type), so we must wrap it in a table. 1043 struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { 1044 typedef MessageContainerT NativeTableType; 1045 enum { 1046 VT_MESSAGE_TYPE = 4, 1047 VT_MESSAGE = 6, 1048 VT_HOST_ADDR = 8 1049 }; 1050 ChreMessage message_type() const { 1051 return static_cast<ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0)); 1052 } 1053 bool mutate_message_type(ChreMessage _message_type) { 1054 return SetField(VT_MESSAGE_TYPE, static_cast<uint8_t>(_message_type)); 1055 } 1056 const void *message() const { 1057 return GetPointer<const void *>(VT_MESSAGE); 1058 } 1059 void *mutable_message() { 1060 return GetPointer<void *>(VT_MESSAGE); 1061 } 1062 /// The originating or destination client ID on the host side, used to direct 1063 /// responses only to the client that sent the request. Although initially 1064 /// populated by the requesting client, this is enforced to be the correct 1065 /// value by the entity guarding access to CHRE. 1066 /// This is wrapped in a struct to ensure that it is always included when 1067 /// encoding the message, so it can be mutated by the host daemon. 1068 const HostAddress *host_addr() const { 1069 return GetStruct<const HostAddress *>(VT_HOST_ADDR); 1070 } 1071 HostAddress *mutable_host_addr() { 1072 return GetStruct<HostAddress *>(VT_HOST_ADDR); 1073 } 1074 bool Verify(flatbuffers::Verifier &verifier) const { 1075 return VerifyTableStart(verifier) && 1076 VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) && 1077 VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) && 1078 VerifyChreMessage(verifier, message(), message_type()) && 1079 VerifyFieldRequired<HostAddress>(verifier, VT_HOST_ADDR) && 1080 verifier.EndTable(); 1081 } 1082 MessageContainerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1083 void UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const; 1084 static flatbuffers::Offset<MessageContainer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1085 }; 1086 1087 struct MessageContainerBuilder { 1088 flatbuffers::FlatBufferBuilder &fbb_; 1089 flatbuffers::uoffset_t start_; 1090 void add_message_type(ChreMessage message_type) { 1091 fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0); 1092 } 1093 void add_message(flatbuffers::Offset<void> message) { 1094 fbb_.AddOffset(MessageContainer::VT_MESSAGE, message); 1095 } 1096 void add_host_addr(const HostAddress *host_addr) { 1097 fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr); 1098 } 1099 MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb) 1100 : fbb_(_fbb) { 1101 start_ = fbb_.StartTable(); 1102 } 1103 MessageContainerBuilder &operator=(const MessageContainerBuilder &); 1104 flatbuffers::Offset<MessageContainer> Finish() { 1105 const auto end = fbb_.EndTable(start_, 3); 1106 auto o = flatbuffers::Offset<MessageContainer>(end); 1107 fbb_.Required(o, MessageContainer::VT_MESSAGE); 1108 fbb_.Required(o, MessageContainer::VT_HOST_ADDR); 1109 return o; 1110 } 1111 }; 1112 1113 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer( 1114 flatbuffers::FlatBufferBuilder &_fbb, 1115 ChreMessage message_type = ChreMessage::NONE, 1116 flatbuffers::Offset<void> message = 0, 1117 const HostAddress *host_addr = 0) { 1118 MessageContainerBuilder builder_(_fbb); 1119 builder_.add_host_addr(host_addr); 1120 builder_.add_message(message); 1121 builder_.add_message_type(message_type); 1122 return builder_.Finish(); 1123 } 1124 1125 flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr); 1126 1127 inline NanoappMessageT *NanoappMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1128 auto _o = new NanoappMessageT(); 1129 UnPackTo(_o, _resolver); 1130 return _o; 1131 } 1132 1133 inline void NanoappMessage::UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1134 (void)_o; 1135 (void)_resolver; 1136 { auto _e = app_id(); _o->app_id = _e; }; 1137 { auto _e = message_type(); _o->message_type = _e; }; 1138 { auto _e = host_endpoint(); _o->host_endpoint = _e; }; 1139 { auto _e = message(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->message.push_back(_e->Get(_i)); } }; 1140 } 1141 1142 inline flatbuffers::Offset<NanoappMessage> NanoappMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1143 return CreateNanoappMessage(_fbb, _o, _rehasher); 1144 } 1145 1146 inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1147 (void)_rehasher; 1148 (void)_o; 1149 auto _app_id = _o->app_id; 1150 auto _message_type = _o->message_type; 1151 auto _host_endpoint = _o->host_endpoint; 1152 auto _message = _fbb.CreateVector(_o->message); 1153 return chre::fbs::CreateNanoappMessage( 1154 _fbb, 1155 _app_id, 1156 _message_type, 1157 _host_endpoint, 1158 _message); 1159 } 1160 1161 inline HubInfoRequestT *HubInfoRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1162 auto _o = new HubInfoRequestT(); 1163 UnPackTo(_o, _resolver); 1164 return _o; 1165 } 1166 1167 inline void HubInfoRequest::UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1168 (void)_o; 1169 (void)_resolver; 1170 } 1171 1172 inline flatbuffers::Offset<HubInfoRequest> HubInfoRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1173 return CreateHubInfoRequest(_fbb, _o, _rehasher); 1174 } 1175 1176 inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1177 (void)_rehasher; 1178 (void)_o; 1179 return chre::fbs::CreateHubInfoRequest( 1180 _fbb); 1181 } 1182 1183 inline HubInfoResponseT *HubInfoResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1184 auto _o = new HubInfoResponseT(); 1185 UnPackTo(_o, _resolver); 1186 return _o; 1187 } 1188 1189 inline void HubInfoResponse::UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1190 (void)_o; 1191 (void)_resolver; 1192 { auto _e = name(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name.push_back(_e->Get(_i)); } }; 1193 { auto _e = vendor(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vendor.push_back(_e->Get(_i)); } }; 1194 { auto _e = toolchain(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->toolchain.push_back(_e->Get(_i)); } }; 1195 { auto _e = platform_version(); _o->platform_version = _e; }; 1196 { auto _e = toolchain_version(); _o->toolchain_version = _e; }; 1197 { auto _e = peak_mips(); _o->peak_mips = _e; }; 1198 { auto _e = stopped_power(); _o->stopped_power = _e; }; 1199 { auto _e = sleep_power(); _o->sleep_power = _e; }; 1200 { auto _e = peak_power(); _o->peak_power = _e; }; 1201 { auto _e = max_msg_len(); _o->max_msg_len = _e; }; 1202 { auto _e = platform_id(); _o->platform_id = _e; }; 1203 { auto _e = chre_platform_version(); _o->chre_platform_version = _e; }; 1204 } 1205 1206 inline flatbuffers::Offset<HubInfoResponse> HubInfoResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1207 return CreateHubInfoResponse(_fbb, _o, _rehasher); 1208 } 1209 1210 inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1211 (void)_rehasher; 1212 (void)_o; 1213 auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0; 1214 auto _vendor = _o->vendor.size() ? _fbb.CreateVector(_o->vendor) : 0; 1215 auto _toolchain = _o->toolchain.size() ? _fbb.CreateVector(_o->toolchain) : 0; 1216 auto _platform_version = _o->platform_version; 1217 auto _toolchain_version = _o->toolchain_version; 1218 auto _peak_mips = _o->peak_mips; 1219 auto _stopped_power = _o->stopped_power; 1220 auto _sleep_power = _o->sleep_power; 1221 auto _peak_power = _o->peak_power; 1222 auto _max_msg_len = _o->max_msg_len; 1223 auto _platform_id = _o->platform_id; 1224 auto _chre_platform_version = _o->chre_platform_version; 1225 return chre::fbs::CreateHubInfoResponse( 1226 _fbb, 1227 _name, 1228 _vendor, 1229 _toolchain, 1230 _platform_version, 1231 _toolchain_version, 1232 _peak_mips, 1233 _stopped_power, 1234 _sleep_power, 1235 _peak_power, 1236 _max_msg_len, 1237 _platform_id, 1238 _chre_platform_version); 1239 } 1240 1241 inline NanoappListRequestT *NanoappListRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1242 auto _o = new NanoappListRequestT(); 1243 UnPackTo(_o, _resolver); 1244 return _o; 1245 } 1246 1247 inline void NanoappListRequest::UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1248 (void)_o; 1249 (void)_resolver; 1250 } 1251 1252 inline flatbuffers::Offset<NanoappListRequest> NanoappListRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1253 return CreateNanoappListRequest(_fbb, _o, _rehasher); 1254 } 1255 1256 inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1257 (void)_rehasher; 1258 (void)_o; 1259 return chre::fbs::CreateNanoappListRequest( 1260 _fbb); 1261 } 1262 1263 inline NanoappListEntryT *NanoappListEntry::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1264 auto _o = new NanoappListEntryT(); 1265 UnPackTo(_o, _resolver); 1266 return _o; 1267 } 1268 1269 inline void NanoappListEntry::UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1270 (void)_o; 1271 (void)_resolver; 1272 { auto _e = app_id(); _o->app_id = _e; }; 1273 { auto _e = version(); _o->version = _e; }; 1274 { auto _e = enabled(); _o->enabled = _e; }; 1275 { auto _e = is_system(); _o->is_system = _e; }; 1276 } 1277 1278 inline flatbuffers::Offset<NanoappListEntry> NanoappListEntry::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1279 return CreateNanoappListEntry(_fbb, _o, _rehasher); 1280 } 1281 1282 inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1283 (void)_rehasher; 1284 (void)_o; 1285 auto _app_id = _o->app_id; 1286 auto _version = _o->version; 1287 auto _enabled = _o->enabled; 1288 auto _is_system = _o->is_system; 1289 return chre::fbs::CreateNanoappListEntry( 1290 _fbb, 1291 _app_id, 1292 _version, 1293 _enabled, 1294 _is_system); 1295 } 1296 1297 inline NanoappListResponseT *NanoappListResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1298 auto _o = new NanoappListResponseT(); 1299 UnPackTo(_o, _resolver); 1300 return _o; 1301 } 1302 1303 inline void NanoappListResponse::UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1304 (void)_o; 1305 (void)_resolver; 1306 { auto _e = nanoapps(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->nanoapps.push_back(std::unique_ptr<NanoappListEntryT>(_e->Get(_i)->UnPack(_resolver))); } }; 1307 } 1308 1309 inline flatbuffers::Offset<NanoappListResponse> NanoappListResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1310 return CreateNanoappListResponse(_fbb, _o, _rehasher); 1311 } 1312 1313 inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1314 (void)_rehasher; 1315 (void)_o; 1316 auto _nanoapps = _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(_o->nanoapps.size(), [&](size_t i) { return CreateNanoappListEntry(_fbb, _o->nanoapps[i].get(), _rehasher); }); 1317 return chre::fbs::CreateNanoappListResponse( 1318 _fbb, 1319 _nanoapps); 1320 } 1321 1322 inline LoadNanoappRequestT *LoadNanoappRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1323 auto _o = new LoadNanoappRequestT(); 1324 UnPackTo(_o, _resolver); 1325 return _o; 1326 } 1327 1328 inline void LoadNanoappRequest::UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1329 (void)_o; 1330 (void)_resolver; 1331 { auto _e = transaction_id(); _o->transaction_id = _e; }; 1332 { auto _e = app_id(); _o->app_id = _e; }; 1333 { auto _e = app_version(); _o->app_version = _e; }; 1334 { auto _e = target_api_version(); _o->target_api_version = _e; }; 1335 { auto _e = app_binary(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->app_binary.push_back(_e->Get(_i)); } }; 1336 } 1337 1338 inline flatbuffers::Offset<LoadNanoappRequest> LoadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1339 return CreateLoadNanoappRequest(_fbb, _o, _rehasher); 1340 } 1341 1342 inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1343 (void)_rehasher; 1344 (void)_o; 1345 auto _transaction_id = _o->transaction_id; 1346 auto _app_id = _o->app_id; 1347 auto _app_version = _o->app_version; 1348 auto _target_api_version = _o->target_api_version; 1349 auto _app_binary = _fbb.CreateVector(_o->app_binary); 1350 return chre::fbs::CreateLoadNanoappRequest( 1351 _fbb, 1352 _transaction_id, 1353 _app_id, 1354 _app_version, 1355 _target_api_version, 1356 _app_binary); 1357 } 1358 1359 inline LoadNanoappResponseT *LoadNanoappResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1360 auto _o = new LoadNanoappResponseT(); 1361 UnPackTo(_o, _resolver); 1362 return _o; 1363 } 1364 1365 inline void LoadNanoappResponse::UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1366 (void)_o; 1367 (void)_resolver; 1368 { auto _e = transaction_id(); _o->transaction_id = _e; }; 1369 { auto _e = success(); _o->success = _e; }; 1370 } 1371 1372 inline flatbuffers::Offset<LoadNanoappResponse> LoadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1373 return CreateLoadNanoappResponse(_fbb, _o, _rehasher); 1374 } 1375 1376 inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1377 (void)_rehasher; 1378 (void)_o; 1379 auto _transaction_id = _o->transaction_id; 1380 auto _success = _o->success; 1381 return chre::fbs::CreateLoadNanoappResponse( 1382 _fbb, 1383 _transaction_id, 1384 _success); 1385 } 1386 1387 inline MessageContainerT *MessageContainer::UnPack(const flatbuffers::resolver_function_t *_resolver) const { 1388 auto _o = new MessageContainerT(); 1389 UnPackTo(_o, _resolver); 1390 return _o; 1391 } 1392 1393 inline void MessageContainer::UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver) const { 1394 (void)_o; 1395 (void)_resolver; 1396 { auto _e = message_type(); _o->message.type = _e; }; 1397 { auto _e = message(); if (_e) _o->message.table = ChreMessageUnion::UnPack(_e, message_type(),_resolver); }; 1398 { auto _e = host_addr(); if (_e) _o->host_addr = std::unique_ptr<HostAddress>(new HostAddress(*_e)); }; 1399 } 1400 1401 inline flatbuffers::Offset<MessageContainer> MessageContainer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher) { 1402 return CreateMessageContainer(_fbb, _o, _rehasher); 1403 } 1404 1405 inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher) { 1406 (void)_rehasher; 1407 (void)_o; 1408 auto _message_type = _o->message.type; 1409 auto _message = _o->message.Pack(_fbb); 1410 auto _host_addr = _o->host_addr ? _o->host_addr.get() : 0; 1411 return chre::fbs::CreateMessageContainer( 1412 _fbb, 1413 _message_type, 1414 _message, 1415 _host_addr); 1416 } 1417 1418 inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) { 1419 switch (type) { 1420 case ChreMessage::NONE: { 1421 return true; 1422 } 1423 case ChreMessage::NanoappMessage: { 1424 auto ptr = reinterpret_cast<const NanoappMessage *>(obj); 1425 return verifier.VerifyTable(ptr); 1426 } 1427 case ChreMessage::HubInfoRequest: { 1428 auto ptr = reinterpret_cast<const HubInfoRequest *>(obj); 1429 return verifier.VerifyTable(ptr); 1430 } 1431 case ChreMessage::HubInfoResponse: { 1432 auto ptr = reinterpret_cast<const HubInfoResponse *>(obj); 1433 return verifier.VerifyTable(ptr); 1434 } 1435 case ChreMessage::NanoappListRequest: { 1436 auto ptr = reinterpret_cast<const NanoappListRequest *>(obj); 1437 return verifier.VerifyTable(ptr); 1438 } 1439 case ChreMessage::NanoappListResponse: { 1440 auto ptr = reinterpret_cast<const NanoappListResponse *>(obj); 1441 return verifier.VerifyTable(ptr); 1442 } 1443 case ChreMessage::LoadNanoappRequest: { 1444 auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj); 1445 return verifier.VerifyTable(ptr); 1446 } 1447 case ChreMessage::LoadNanoappResponse: { 1448 auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj); 1449 return verifier.VerifyTable(ptr); 1450 } 1451 default: return false; 1452 } 1453 } 1454 1455 inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { 1456 if (values->size() != types->size()) return false; 1457 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { 1458 if (!VerifyChreMessage( 1459 verifier, values->Get(i), types->GetEnum<ChreMessage>(i))) { 1460 return false; 1461 } 1462 } 1463 return true; 1464 } 1465 1466 inline flatbuffers::NativeTable *ChreMessageUnion::UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver) { 1467 switch (type) { 1468 case ChreMessage::NanoappMessage: { 1469 auto ptr = reinterpret_cast<const NanoappMessage *>(obj); 1470 return ptr->UnPack(resolver); 1471 } 1472 case ChreMessage::HubInfoRequest: { 1473 auto ptr = reinterpret_cast<const HubInfoRequest *>(obj); 1474 return ptr->UnPack(resolver); 1475 } 1476 case ChreMessage::HubInfoResponse: { 1477 auto ptr = reinterpret_cast<const HubInfoResponse *>(obj); 1478 return ptr->UnPack(resolver); 1479 } 1480 case ChreMessage::NanoappListRequest: { 1481 auto ptr = reinterpret_cast<const NanoappListRequest *>(obj); 1482 return ptr->UnPack(resolver); 1483 } 1484 case ChreMessage::NanoappListResponse: { 1485 auto ptr = reinterpret_cast<const NanoappListResponse *>(obj); 1486 return ptr->UnPack(resolver); 1487 } 1488 case ChreMessage::LoadNanoappRequest: { 1489 auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj); 1490 return ptr->UnPack(resolver); 1491 } 1492 case ChreMessage::LoadNanoappResponse: { 1493 auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj); 1494 return ptr->UnPack(resolver); 1495 } 1496 default: return nullptr; 1497 } 1498 } 1499 1500 inline flatbuffers::Offset<void> ChreMessageUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const { 1501 switch (type) { 1502 case ChreMessage::NanoappMessage: { 1503 auto ptr = reinterpret_cast<const NanoappMessageT *>(table); 1504 return CreateNanoappMessage(_fbb, ptr, _rehasher).Union(); 1505 } 1506 case ChreMessage::HubInfoRequest: { 1507 auto ptr = reinterpret_cast<const HubInfoRequestT *>(table); 1508 return CreateHubInfoRequest(_fbb, ptr, _rehasher).Union(); 1509 } 1510 case ChreMessage::HubInfoResponse: { 1511 auto ptr = reinterpret_cast<const HubInfoResponseT *>(table); 1512 return CreateHubInfoResponse(_fbb, ptr, _rehasher).Union(); 1513 } 1514 case ChreMessage::NanoappListRequest: { 1515 auto ptr = reinterpret_cast<const NanoappListRequestT *>(table); 1516 return CreateNanoappListRequest(_fbb, ptr, _rehasher).Union(); 1517 } 1518 case ChreMessage::NanoappListResponse: { 1519 auto ptr = reinterpret_cast<const NanoappListResponseT *>(table); 1520 return CreateNanoappListResponse(_fbb, ptr, _rehasher).Union(); 1521 } 1522 case ChreMessage::LoadNanoappRequest: { 1523 auto ptr = reinterpret_cast<const LoadNanoappRequestT *>(table); 1524 return CreateLoadNanoappRequest(_fbb, ptr, _rehasher).Union(); 1525 } 1526 case ChreMessage::LoadNanoappResponse: { 1527 auto ptr = reinterpret_cast<const LoadNanoappResponseT *>(table); 1528 return CreateLoadNanoappResponse(_fbb, ptr, _rehasher).Union(); 1529 } 1530 default: return 0; 1531 } 1532 } 1533 1534 inline void ChreMessageUnion::Reset() { 1535 switch (type) { 1536 case ChreMessage::NanoappMessage: { 1537 auto ptr = reinterpret_cast<NanoappMessageT *>(table); 1538 delete ptr; 1539 break; 1540 } 1541 case ChreMessage::HubInfoRequest: { 1542 auto ptr = reinterpret_cast<HubInfoRequestT *>(table); 1543 delete ptr; 1544 break; 1545 } 1546 case ChreMessage::HubInfoResponse: { 1547 auto ptr = reinterpret_cast<HubInfoResponseT *>(table); 1548 delete ptr; 1549 break; 1550 } 1551 case ChreMessage::NanoappListRequest: { 1552 auto ptr = reinterpret_cast<NanoappListRequestT *>(table); 1553 delete ptr; 1554 break; 1555 } 1556 case ChreMessage::NanoappListResponse: { 1557 auto ptr = reinterpret_cast<NanoappListResponseT *>(table); 1558 delete ptr; 1559 break; 1560 } 1561 case ChreMessage::LoadNanoappRequest: { 1562 auto ptr = reinterpret_cast<LoadNanoappRequestT *>(table); 1563 delete ptr; 1564 break; 1565 } 1566 case ChreMessage::LoadNanoappResponse: { 1567 auto ptr = reinterpret_cast<LoadNanoappResponseT *>(table); 1568 delete ptr; 1569 break; 1570 } 1571 default: break; 1572 } 1573 table = nullptr; 1574 type = ChreMessage::NONE; 1575 } 1576 1577 inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) { 1578 return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf); 1579 } 1580 1581 inline MessageContainer *GetMutableMessageContainer(void *buf) { 1582 return flatbuffers::GetMutableRoot<MessageContainer>(buf); 1583 } 1584 1585 inline bool VerifyMessageContainerBuffer( 1586 flatbuffers::Verifier &verifier) { 1587 return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr); 1588 } 1589 1590 inline void FinishMessageContainerBuffer( 1591 flatbuffers::FlatBufferBuilder &fbb, 1592 flatbuffers::Offset<chre::fbs::MessageContainer> root) { 1593 fbb.Finish(root); 1594 } 1595 1596 inline std::unique_ptr<MessageContainerT> UnPackMessageContainer( 1597 const void *buf, 1598 const flatbuffers::resolver_function_t *res = nullptr) { 1599 return std::unique_ptr<MessageContainerT>(GetMessageContainer(buf)->UnPack(res)); 1600 } 1601 1602 } // namespace fbs 1603 } // namespace chre 1604 1605 #endif // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_ 1606
