host_messages_generated.h revision 58276308709e5568ba2976e93b37211a52589166 
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
9namespace chre {
10namespace fbs {
11
12struct NanoappMessage;
13struct NanoappMessageT;
14
15struct HubInfoRequest;
16struct HubInfoRequestT;
17
18struct HubInfoResponse;
19struct HubInfoResponseT;
20
21struct NanoappListRequest;
22struct NanoappListRequestT;
23
24struct NanoappListEntry;
25struct NanoappListEntryT;
26
27struct NanoappListResponse;
28struct NanoappListResponseT;
29
30struct LoadNanoappRequest;
31struct LoadNanoappRequestT;
32
33struct LoadNanoappResponse;
34struct LoadNanoappResponseT;
35
36struct UnloadNanoappRequest;
37struct UnloadNanoappRequestT;
38
39struct UnloadNanoappResponse;
40struct UnloadNanoappResponseT;
41
42struct LogMessage;
43struct LogMessageT;
44
45struct TimeSyncMessage;
46struct TimeSyncMessageT;
47
48struct DebugDumpRequest;
49struct DebugDumpRequestT;
50
51struct DebugDumpData;
52struct DebugDumpDataT;
53
54struct DebugDumpResponse;
55struct DebugDumpResponseT;
56
57struct HostAddress;
58
59struct MessageContainer;
60struct MessageContainerT;
61
62/// A union that joins together all possible messages. Note that in FlatBuffers,
63/// unions have an implicit type
64enum class ChreMessage : uint8_t {
65  NONE = 0,
66  NanoappMessage = 1,
67  HubInfoRequest = 2,
68  HubInfoResponse = 3,
69  NanoappListRequest = 4,
70  NanoappListResponse = 5,
71  LoadNanoappRequest = 6,
72  LoadNanoappResponse = 7,
73  UnloadNanoappRequest = 8,
74  UnloadNanoappResponse = 9,
75  LogMessage = 10,
76  TimeSyncMessage = 11,
77  DebugDumpRequest = 12,
78  DebugDumpData = 13,
79  DebugDumpResponse = 14,
80  MIN = NONE,
81  MAX = DebugDumpResponse
82};
83
84inline const char **EnumNamesChreMessage() {
85  static const char *names[] = {
86    "NONE",
87    "NanoappMessage",
88    "HubInfoRequest",
89    "HubInfoResponse",
90    "NanoappListRequest",
91    "NanoappListResponse",
92    "LoadNanoappRequest",
93    "LoadNanoappResponse",
94    "UnloadNanoappRequest",
95    "UnloadNanoappResponse",
96    "LogMessage",
97    "TimeSyncMessage",
98    "DebugDumpRequest",
99    "DebugDumpData",
100    "DebugDumpResponse",
101    nullptr
102  };
103  return names;
104}
105
106inline const char *EnumNameChreMessage(ChreMessage e) {
107  const size_t index = static_cast<int>(e);
108  return EnumNamesChreMessage()[index];
109}
110
111template<typename T> struct ChreMessageTraits {
112  static const ChreMessage enum_value = ChreMessage::NONE;
113};
114
115template<> struct ChreMessageTraits<NanoappMessage> {
116  static const ChreMessage enum_value = ChreMessage::NanoappMessage;
117};
118
119template<> struct ChreMessageTraits<HubInfoRequest> {
120  static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
121};
122
123template<> struct ChreMessageTraits<HubInfoResponse> {
124  static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
125};
126
127template<> struct ChreMessageTraits<NanoappListRequest> {
128  static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
129};
130
131template<> struct ChreMessageTraits<NanoappListResponse> {
132  static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
133};
134
135template<> struct ChreMessageTraits<LoadNanoappRequest> {
136  static const ChreMessage enum_value = ChreMessage::LoadNanoappRequest;
137};
138
139template<> struct ChreMessageTraits<LoadNanoappResponse> {
140  static const ChreMessage enum_value = ChreMessage::LoadNanoappResponse;
141};
142
143template<> struct ChreMessageTraits<UnloadNanoappRequest> {
144  static const ChreMessage enum_value = ChreMessage::UnloadNanoappRequest;
145};
146
147template<> struct ChreMessageTraits<UnloadNanoappResponse> {
148  static const ChreMessage enum_value = ChreMessage::UnloadNanoappResponse;
149};
150
151template<> struct ChreMessageTraits<LogMessage> {
152  static const ChreMessage enum_value = ChreMessage::LogMessage;
153};
154
155template<> struct ChreMessageTraits<TimeSyncMessage> {
156  static const ChreMessage enum_value = ChreMessage::TimeSyncMessage;
157};
158
159template<> struct ChreMessageTraits<DebugDumpRequest> {
160  static const ChreMessage enum_value = ChreMessage::DebugDumpRequest;
161};
162
163template<> struct ChreMessageTraits<DebugDumpData> {
164  static const ChreMessage enum_value = ChreMessage::DebugDumpData;
165};
166
167template<> struct ChreMessageTraits<DebugDumpResponse> {
168  static const ChreMessage enum_value = ChreMessage::DebugDumpResponse;
169};
170
171struct ChreMessageUnion {
172  ChreMessage type;
173  flatbuffers::NativeTable *table;
174
175  ChreMessageUnion() : type(ChreMessage::NONE), table(nullptr) {}
176  ChreMessageUnion(ChreMessageUnion&& u):
177    type(std::move(u.type)), table(std::move(u.table)) {}
178  ChreMessageUnion(const ChreMessageUnion &);
179  ChreMessageUnion &operator=(const ChreMessageUnion &);
180  ~ChreMessageUnion() { Reset(); }
181
182  void Reset();
183
184  template <typename T>
185  void Set(T&& value) {
186    Reset();
187    type = ChreMessageTraits<typename T::TableType>::enum_value;
188    if (type != ChreMessage::NONE) {
189      table = new T(std::forward<T>(value));
190    }
191  }
192
193  static flatbuffers::NativeTable *UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver);
194  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
195
196  NanoappMessageT *AsNanoappMessage() {
197    return type == ChreMessage::NanoappMessage ?
198      reinterpret_cast<NanoappMessageT *>(table) : nullptr;
199  }
200  HubInfoRequestT *AsHubInfoRequest() {
201    return type == ChreMessage::HubInfoRequest ?
202      reinterpret_cast<HubInfoRequestT *>(table) : nullptr;
203  }
204  HubInfoResponseT *AsHubInfoResponse() {
205    return type == ChreMessage::HubInfoResponse ?
206      reinterpret_cast<HubInfoResponseT *>(table) : nullptr;
207  }
208  NanoappListRequestT *AsNanoappListRequest() {
209    return type == ChreMessage::NanoappListRequest ?
210      reinterpret_cast<NanoappListRequestT *>(table) : nullptr;
211  }
212  NanoappListResponseT *AsNanoappListResponse() {
213    return type == ChreMessage::NanoappListResponse ?
214      reinterpret_cast<NanoappListResponseT *>(table) : nullptr;
215  }
216  LoadNanoappRequestT *AsLoadNanoappRequest() {
217    return type == ChreMessage::LoadNanoappRequest ?
218      reinterpret_cast<LoadNanoappRequestT *>(table) : nullptr;
219  }
220  LoadNanoappResponseT *AsLoadNanoappResponse() {
221    return type == ChreMessage::LoadNanoappResponse ?
222      reinterpret_cast<LoadNanoappResponseT *>(table) : nullptr;
223  }
224  UnloadNanoappRequestT *AsUnloadNanoappRequest() {
225    return type == ChreMessage::UnloadNanoappRequest ?
226      reinterpret_cast<UnloadNanoappRequestT *>(table) : nullptr;
227  }
228  UnloadNanoappResponseT *AsUnloadNanoappResponse() {
229    return type == ChreMessage::UnloadNanoappResponse ?
230      reinterpret_cast<UnloadNanoappResponseT *>(table) : nullptr;
231  }
232  LogMessageT *AsLogMessage() {
233    return type == ChreMessage::LogMessage ?
234      reinterpret_cast<LogMessageT *>(table) : nullptr;
235  }
236  TimeSyncMessageT *AsTimeSyncMessage() {
237    return type == ChreMessage::TimeSyncMessage ?
238      reinterpret_cast<TimeSyncMessageT *>(table) : nullptr;
239  }
240  DebugDumpRequestT *AsDebugDumpRequest() {
241    return type == ChreMessage::DebugDumpRequest ?
242      reinterpret_cast<DebugDumpRequestT *>(table) : nullptr;
243  }
244  DebugDumpDataT *AsDebugDumpData() {
245    return type == ChreMessage::DebugDumpData ?
246      reinterpret_cast<DebugDumpDataT *>(table) : nullptr;
247  }
248  DebugDumpResponseT *AsDebugDumpResponse() {
249    return type == ChreMessage::DebugDumpResponse ?
250      reinterpret_cast<DebugDumpResponseT *>(table) : nullptr;
251  }
252};
253
254bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
255bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
256
257MANUALLY_ALIGNED_STRUCT(2) HostAddress FLATBUFFERS_FINAL_CLASS {
258 private:
259  uint16_t client_id_;
260
261 public:
262  HostAddress() {
263    memset(this, 0, sizeof(HostAddress));
264  }
265  HostAddress(const HostAddress &_o) {
266    memcpy(this, &_o, sizeof(HostAddress));
267  }
268  HostAddress(uint16_t _client_id)
269      : client_id_(flatbuffers::EndianScalar(_client_id)) {
270  }
271  uint16_t client_id() const {
272    return flatbuffers::EndianScalar(client_id_);
273  }
274  void mutate_client_id(uint16_t _client_id) {
275    flatbuffers::WriteScalar(&client_id_, _client_id);
276  }
277};
278STRUCT_END(HostAddress, 2);
279
280struct NanoappMessageT : public flatbuffers::NativeTable {
281  typedef NanoappMessage TableType;
282  uint64_t app_id;
283  uint32_t message_type;
284  uint16_t host_endpoint;
285  std::vector<uint8_t> message;
286  NanoappMessageT()
287      : app_id(0),
288        message_type(0),
289        host_endpoint(65534) {
290  }
291};
292
293/// Represents a message sent to/from a nanoapp from/to a client on the host
294struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
295  typedef NanoappMessageT NativeTableType;
296  enum {
297    VT_APP_ID = 4,
298    VT_MESSAGE_TYPE = 6,
299    VT_HOST_ENDPOINT = 8,
300    VT_MESSAGE = 10
301  };
302  uint64_t app_id() const {
303    return GetField<uint64_t>(VT_APP_ID, 0);
304  }
305  bool mutate_app_id(uint64_t _app_id) {
306    return SetField(VT_APP_ID, _app_id);
307  }
308  uint32_t message_type() const {
309    return GetField<uint32_t>(VT_MESSAGE_TYPE, 0);
310  }
311  bool mutate_message_type(uint32_t _message_type) {
312    return SetField(VT_MESSAGE_TYPE, _message_type);
313  }
314  /// Identifies the host-side endpoint on the host that sent or should receive
315  /// this message. The default value is a special value defined in the HAL and
316  /// elsewhere that indicates that the endpoint is unspecified.
317  uint16_t host_endpoint() const {
318    return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534);
319  }
320  bool mutate_host_endpoint(uint16_t _host_endpoint) {
321    return SetField(VT_HOST_ENDPOINT, _host_endpoint);
322  }
323  /// Vector containing arbitrary application-specific message data
324  const flatbuffers::Vector<uint8_t> *message() const {
325    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
326  }
327  flatbuffers::Vector<uint8_t> *mutable_message() {
328    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
329  }
330  bool Verify(flatbuffers::Verifier &verifier) const {
331    return VerifyTableStart(verifier) &&
332           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
333           VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) &&
334           VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
335           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
336           verifier.Verify(message()) &&
337           verifier.EndTable();
338  }
339  NanoappMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
340  void UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
341  static flatbuffers::Offset<NanoappMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
342};
343
344struct NanoappMessageBuilder {
345  flatbuffers::FlatBufferBuilder &fbb_;
346  flatbuffers::uoffset_t start_;
347  void add_app_id(uint64_t app_id) {
348    fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0);
349  }
350  void add_message_type(uint32_t message_type) {
351    fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0);
352  }
353  void add_host_endpoint(uint16_t host_endpoint) {
354    fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534);
355  }
356  void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
357    fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message);
358  }
359  NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
360        : fbb_(_fbb) {
361    start_ = fbb_.StartTable();
362  }
363  NanoappMessageBuilder &operator=(const NanoappMessageBuilder &);
364  flatbuffers::Offset<NanoappMessage> Finish() {
365    const auto end = fbb_.EndTable(start_, 4);
366    auto o = flatbuffers::Offset<NanoappMessage>(end);
367    fbb_.Required(o, NanoappMessage::VT_MESSAGE);
368    return o;
369  }
370};
371
372inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(
373    flatbuffers::FlatBufferBuilder &_fbb,
374    uint64_t app_id = 0,
375    uint32_t message_type = 0,
376    uint16_t host_endpoint = 65534,
377    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0) {
378  NanoappMessageBuilder builder_(_fbb);
379  builder_.add_app_id(app_id);
380  builder_.add_message(message);
381  builder_.add_message_type(message_type);
382  builder_.add_host_endpoint(host_endpoint);
383  return builder_.Finish();
384}
385
386inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect(
387    flatbuffers::FlatBufferBuilder &_fbb,
388    uint64_t app_id = 0,
389    uint32_t message_type = 0,
390    uint16_t host_endpoint = 65534,
391    const std::vector<uint8_t> *message = nullptr) {
392  return chre::fbs::CreateNanoappMessage(
393      _fbb,
394      app_id,
395      message_type,
396      host_endpoint,
397      message ? _fbb.CreateVector<uint8_t>(*message) : 0);
398}
399
400flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
401
402struct HubInfoRequestT : public flatbuffers::NativeTable {
403  typedef HubInfoRequest TableType;
404  HubInfoRequestT() {
405  }
406};
407
408struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
409  typedef HubInfoRequestT NativeTableType;
410  bool Verify(flatbuffers::Verifier &verifier) const {
411    return VerifyTableStart(verifier) &&
412           verifier.EndTable();
413  }
414  HubInfoRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
415  void UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
416  static flatbuffers::Offset<HubInfoRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
417};
418
419struct HubInfoRequestBuilder {
420  flatbuffers::FlatBufferBuilder &fbb_;
421  flatbuffers::uoffset_t start_;
422  HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
423        : fbb_(_fbb) {
424    start_ = fbb_.StartTable();
425  }
426  HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &);
427  flatbuffers::Offset<HubInfoRequest> Finish() {
428    const auto end = fbb_.EndTable(start_, 0);
429    auto o = flatbuffers::Offset<HubInfoRequest>(end);
430    return o;
431  }
432};
433
434inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
435    flatbuffers::FlatBufferBuilder &_fbb) {
436  HubInfoRequestBuilder builder_(_fbb);
437  return builder_.Finish();
438}
439
440flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
441
442struct HubInfoResponseT : public flatbuffers::NativeTable {
443  typedef HubInfoResponse TableType;
444  std::vector<int8_t> name;
445  std::vector<int8_t> vendor;
446  std::vector<int8_t> toolchain;
447  uint32_t platform_version;
448  uint32_t toolchain_version;
449  float peak_mips;
450  float stopped_power;
451  float sleep_power;
452  float peak_power;
453  uint32_t max_msg_len;
454  uint64_t platform_id;
455  uint32_t chre_platform_version;
456  HubInfoResponseT()
457      : platform_version(0),
458        toolchain_version(0),
459        peak_mips(0.0f),
460        stopped_power(0.0f),
461        sleep_power(0.0f),
462        peak_power(0.0f),
463        max_msg_len(0),
464        platform_id(0),
465        chre_platform_version(0) {
466  }
467};
468
469struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
470  typedef HubInfoResponseT NativeTableType;
471  enum {
472    VT_NAME = 4,
473    VT_VENDOR = 6,
474    VT_TOOLCHAIN = 8,
475    VT_PLATFORM_VERSION = 10,
476    VT_TOOLCHAIN_VERSION = 12,
477    VT_PEAK_MIPS = 14,
478    VT_STOPPED_POWER = 16,
479    VT_SLEEP_POWER = 18,
480    VT_PEAK_POWER = 20,
481    VT_MAX_MSG_LEN = 22,
482    VT_PLATFORM_ID = 24,
483    VT_CHRE_PLATFORM_VERSION = 26
484  };
485  /// The name of the hub. Nominally a UTF-8 string, but note that we're not
486  /// using the built-in "string" data type from FlatBuffers here, because the
487  /// generated C++ uses std::string which is not well-supported in CHRE. This
488  /// applies for vendor and toolchain as well.
489  const flatbuffers::Vector<int8_t> *name() const {
490    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
491  }
492  flatbuffers::Vector<int8_t> *mutable_name() {
493    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME);
494  }
495  const flatbuffers::Vector<int8_t> *vendor() const {
496    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR);
497  }
498  flatbuffers::Vector<int8_t> *mutable_vendor() {
499    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VENDOR);
500  }
501  const flatbuffers::Vector<int8_t> *toolchain() const {
502    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
503  }
504  flatbuffers::Vector<int8_t> *mutable_toolchain() {
505    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
506  }
507  /// Legacy platform version reported in the HAL; semantics not strictly
508  /// defined
509  uint32_t platform_version() const {
510    return GetField<uint32_t>(VT_PLATFORM_VERSION, 0);
511  }
512  bool mutate_platform_version(uint32_t _platform_version) {
513    return SetField(VT_PLATFORM_VERSION, _platform_version);
514  }
515  /// Toolchain version reported in the HAL; semantics not strictly defined
516  uint32_t toolchain_version() const {
517    return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0);
518  }
519  bool mutate_toolchain_version(uint32_t _toolchain_version) {
520    return SetField(VT_TOOLCHAIN_VERSION, _toolchain_version);
521  }
522  float peak_mips() const {
523    return GetField<float>(VT_PEAK_MIPS, 0.0f);
524  }
525  bool mutate_peak_mips(float _peak_mips) {
526    return SetField(VT_PEAK_MIPS, _peak_mips);
527  }
528  float stopped_power() const {
529    return GetField<float>(VT_STOPPED_POWER, 0.0f);
530  }
531  bool mutate_stopped_power(float _stopped_power) {
532    return SetField(VT_STOPPED_POWER, _stopped_power);
533  }
534  float sleep_power() const {
535    return GetField<float>(VT_SLEEP_POWER, 0.0f);
536  }
537  bool mutate_sleep_power(float _sleep_power) {
538    return SetField(VT_SLEEP_POWER, _sleep_power);
539  }
540  float peak_power() const {
541    return GetField<float>(VT_PEAK_POWER, 0.0f);
542  }
543  bool mutate_peak_power(float _peak_power) {
544    return SetField(VT_PEAK_POWER, _peak_power);
545  }
546  /// Maximum size message that can be sent to a nanoapp
547  uint32_t max_msg_len() const {
548    return GetField<uint32_t>(VT_MAX_MSG_LEN, 0);
549  }
550  bool mutate_max_msg_len(uint32_t _max_msg_len) {
551    return SetField(VT_MAX_MSG_LEN, _max_msg_len);
552  }
553  /// @see chreGetPlatformId()
554  uint64_t platform_id() const {
555    return GetField<uint64_t>(VT_PLATFORM_ID, 0);
556  }
557  bool mutate_platform_id(uint64_t _platform_id) {
558    return SetField(VT_PLATFORM_ID, _platform_id);
559  }
560  /// @see chreGetVersion()
561  uint32_t chre_platform_version() const {
562    return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0);
563  }
564  bool mutate_chre_platform_version(uint32_t _chre_platform_version) {
565    return SetField(VT_CHRE_PLATFORM_VERSION, _chre_platform_version);
566  }
567  bool Verify(flatbuffers::Verifier &verifier) const {
568    return VerifyTableStart(verifier) &&
569           VerifyField<flatbuffers::uoffset_t>(verifier, VT_NAME) &&
570           verifier.Verify(name()) &&
571           VerifyField<flatbuffers::uoffset_t>(verifier, VT_VENDOR) &&
572           verifier.Verify(vendor()) &&
573           VerifyField<flatbuffers::uoffset_t>(verifier, VT_TOOLCHAIN) &&
574           verifier.Verify(toolchain()) &&
575           VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) &&
576           VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) &&
577           VerifyField<float>(verifier, VT_PEAK_MIPS) &&
578           VerifyField<float>(verifier, VT_STOPPED_POWER) &&
579           VerifyField<float>(verifier, VT_SLEEP_POWER) &&
580           VerifyField<float>(verifier, VT_PEAK_POWER) &&
581           VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) &&
582           VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) &&
583           VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) &&
584           verifier.EndTable();
585  }
586  HubInfoResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
587  void UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
588  static flatbuffers::Offset<HubInfoResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
589};
590
591struct HubInfoResponseBuilder {
592  flatbuffers::FlatBufferBuilder &fbb_;
593  flatbuffers::uoffset_t start_;
594  void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
595    fbb_.AddOffset(HubInfoResponse::VT_NAME, name);
596  }
597  void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) {
598    fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor);
599  }
600  void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) {
601    fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain);
602  }
603  void add_platform_version(uint32_t platform_version) {
604    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0);
605  }
606  void add_toolchain_version(uint32_t toolchain_version) {
607    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0);
608  }
609  void add_peak_mips(float peak_mips) {
610    fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f);
611  }
612  void add_stopped_power(float stopped_power) {
613    fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f);
614  }
615  void add_sleep_power(float sleep_power) {
616    fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f);
617  }
618  void add_peak_power(float peak_power) {
619    fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f);
620  }
621  void add_max_msg_len(uint32_t max_msg_len) {
622    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0);
623  }
624  void add_platform_id(uint64_t platform_id) {
625    fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0);
626  }
627  void add_chre_platform_version(uint32_t chre_platform_version) {
628    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0);
629  }
630  HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
631        : fbb_(_fbb) {
632    start_ = fbb_.StartTable();
633  }
634  HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &);
635  flatbuffers::Offset<HubInfoResponse> Finish() {
636    const auto end = fbb_.EndTable(start_, 12);
637    auto o = flatbuffers::Offset<HubInfoResponse>(end);
638    return o;
639  }
640};
641
642inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(
643    flatbuffers::FlatBufferBuilder &_fbb,
644    flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
645    flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0,
646    flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0,
647    uint32_t platform_version = 0,
648    uint32_t toolchain_version = 0,
649    float peak_mips = 0.0f,
650    float stopped_power = 0.0f,
651    float sleep_power = 0.0f,
652    float peak_power = 0.0f,
653    uint32_t max_msg_len = 0,
654    uint64_t platform_id = 0,
655    uint32_t chre_platform_version = 0) {
656  HubInfoResponseBuilder builder_(_fbb);
657  builder_.add_platform_id(platform_id);
658  builder_.add_chre_platform_version(chre_platform_version);
659  builder_.add_max_msg_len(max_msg_len);
660  builder_.add_peak_power(peak_power);
661  builder_.add_sleep_power(sleep_power);
662  builder_.add_stopped_power(stopped_power);
663  builder_.add_peak_mips(peak_mips);
664  builder_.add_toolchain_version(toolchain_version);
665  builder_.add_platform_version(platform_version);
666  builder_.add_toolchain(toolchain);
667  builder_.add_vendor(vendor);
668  builder_.add_name(name);
669  return builder_.Finish();
670}
671
672inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect(
673    flatbuffers::FlatBufferBuilder &_fbb,
674    const std::vector<int8_t> *name = nullptr,
675    const std::vector<int8_t> *vendor = nullptr,
676    const std::vector<int8_t> *toolchain = nullptr,
677    uint32_t platform_version = 0,
678    uint32_t toolchain_version = 0,
679    float peak_mips = 0.0f,
680    float stopped_power = 0.0f,
681    float sleep_power = 0.0f,
682    float peak_power = 0.0f,
683    uint32_t max_msg_len = 0,
684    uint64_t platform_id = 0,
685    uint32_t chre_platform_version = 0) {
686  return chre::fbs::CreateHubInfoResponse(
687      _fbb,
688      name ? _fbb.CreateVector<int8_t>(*name) : 0,
689      vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0,
690      toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0,
691      platform_version,
692      toolchain_version,
693      peak_mips,
694      stopped_power,
695      sleep_power,
696      peak_power,
697      max_msg_len,
698      platform_id,
699      chre_platform_version);
700}
701
702flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
703
704struct NanoappListRequestT : public flatbuffers::NativeTable {
705  typedef NanoappListRequest TableType;
706  NanoappListRequestT() {
707  }
708};
709
710struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
711  typedef NanoappListRequestT NativeTableType;
712  bool Verify(flatbuffers::Verifier &verifier) const {
713    return VerifyTableStart(verifier) &&
714           verifier.EndTable();
715  }
716  NanoappListRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
717  void UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
718  static flatbuffers::Offset<NanoappListRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
719};
720
721struct NanoappListRequestBuilder {
722  flatbuffers::FlatBufferBuilder &fbb_;
723  flatbuffers::uoffset_t start_;
724  NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
725        : fbb_(_fbb) {
726    start_ = fbb_.StartTable();
727  }
728  NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &);
729  flatbuffers::Offset<NanoappListRequest> Finish() {
730    const auto end = fbb_.EndTable(start_, 0);
731    auto o = flatbuffers::Offset<NanoappListRequest>(end);
732    return o;
733  }
734};
735
736inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
737    flatbuffers::FlatBufferBuilder &_fbb) {
738  NanoappListRequestBuilder builder_(_fbb);
739  return builder_.Finish();
740}
741
742flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
743
744struct NanoappListEntryT : public flatbuffers::NativeTable {
745  typedef NanoappListEntry TableType;
746  uint64_t app_id;
747  uint32_t version;
748  bool enabled;
749  bool is_system;
750  NanoappListEntryT()
751      : app_id(0),
752        version(0),
753        enabled(true),
754        is_system(false) {
755  }
756};
757
758struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
759  typedef NanoappListEntryT NativeTableType;
760  enum {
761    VT_APP_ID = 4,
762    VT_VERSION = 6,
763    VT_ENABLED = 8,
764    VT_IS_SYSTEM = 10
765  };
766  uint64_t app_id() const {
767    return GetField<uint64_t>(VT_APP_ID, 0);
768  }
769  bool mutate_app_id(uint64_t _app_id) {
770    return SetField(VT_APP_ID, _app_id);
771  }
772  uint32_t version() const {
773    return GetField<uint32_t>(VT_VERSION, 0);
774  }
775  bool mutate_version(uint32_t _version) {
776    return SetField(VT_VERSION, _version);
777  }
778  bool enabled() const {
779    return GetField<uint8_t>(VT_ENABLED, 1) != 0;
780  }
781  bool mutate_enabled(bool _enabled) {
782    return SetField(VT_ENABLED, static_cast<uint8_t>(_enabled));
783  }
784  /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should
785  /// not show up in the list of nanoapps in the context hub HAL. System
786  /// nanoapps are typically used to leverage CHRE for some device functionality
787  /// and do not interact via the context hub HAL.
788  bool is_system() const {
789    return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0;
790  }
791  bool mutate_is_system(bool _is_system) {
792    return SetField(VT_IS_SYSTEM, static_cast<uint8_t>(_is_system));
793  }
794  bool Verify(flatbuffers::Verifier &verifier) const {
795    return VerifyTableStart(verifier) &&
796           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
797           VerifyField<uint32_t>(verifier, VT_VERSION) &&
798           VerifyField<uint8_t>(verifier, VT_ENABLED) &&
799           VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) &&
800           verifier.EndTable();
801  }
802  NanoappListEntryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
803  void UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
804  static flatbuffers::Offset<NanoappListEntry> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
805};
806
807struct NanoappListEntryBuilder {
808  flatbuffers::FlatBufferBuilder &fbb_;
809  flatbuffers::uoffset_t start_;
810  void add_app_id(uint64_t app_id) {
811    fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0);
812  }
813  void add_version(uint32_t version) {
814    fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0);
815  }
816  void add_enabled(bool enabled) {
817    fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
818  }
819  void add_is_system(bool is_system) {
820    fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0);
821  }
822  NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
823        : fbb_(_fbb) {
824    start_ = fbb_.StartTable();
825  }
826  NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &);
827  flatbuffers::Offset<NanoappListEntry> Finish() {
828    const auto end = fbb_.EndTable(start_, 4);
829    auto o = flatbuffers::Offset<NanoappListEntry>(end);
830    return o;
831  }
832};
833
834inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(
835    flatbuffers::FlatBufferBuilder &_fbb,
836    uint64_t app_id = 0,
837    uint32_t version = 0,
838    bool enabled = true,
839    bool is_system = false) {
840  NanoappListEntryBuilder builder_(_fbb);
841  builder_.add_app_id(app_id);
842  builder_.add_version(version);
843  builder_.add_is_system(is_system);
844  builder_.add_enabled(enabled);
845  return builder_.Finish();
846}
847
848flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
849
850struct NanoappListResponseT : public flatbuffers::NativeTable {
851  typedef NanoappListResponse TableType;
852  std::vector<std::unique_ptr<NanoappListEntryT>> nanoapps;
853  NanoappListResponseT() {
854  }
855};
856
857struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
858  typedef NanoappListResponseT NativeTableType;
859  enum {
860    VT_NANOAPPS = 4
861  };
862  const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps() const {
863    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS);
864  }
865  flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *mutable_nanoapps() {
866    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS);
867  }
868  bool Verify(flatbuffers::Verifier &verifier) const {
869    return VerifyTableStart(verifier) &&
870           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NANOAPPS) &&
871           verifier.Verify(nanoapps()) &&
872           verifier.VerifyVectorOfTables(nanoapps()) &&
873           verifier.EndTable();
874  }
875  NanoappListResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
876  void UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
877  static flatbuffers::Offset<NanoappListResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
878};
879
880struct NanoappListResponseBuilder {
881  flatbuffers::FlatBufferBuilder &fbb_;
882  flatbuffers::uoffset_t start_;
883  void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps) {
884    fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps);
885  }
886  NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
887        : fbb_(_fbb) {
888    start_ = fbb_.StartTable();
889  }
890  NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &);
891  flatbuffers::Offset<NanoappListResponse> Finish() {
892    const auto end = fbb_.EndTable(start_, 1);
893    auto o = flatbuffers::Offset<NanoappListResponse>(end);
894    fbb_.Required(o, NanoappListResponse::VT_NANOAPPS);
895    return o;
896  }
897};
898
899inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(
900    flatbuffers::FlatBufferBuilder &_fbb,
901    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps = 0) {
902  NanoappListResponseBuilder builder_(_fbb);
903  builder_.add_nanoapps(nanoapps);
904  return builder_.Finish();
905}
906
907inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect(
908    flatbuffers::FlatBufferBuilder &_fbb,
909    const std::vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps = nullptr) {
910  return chre::fbs::CreateNanoappListResponse(
911      _fbb,
912      nanoapps ? _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(*nanoapps) : 0);
913}
914
915flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
916
917struct LoadNanoappRequestT : public flatbuffers::NativeTable {
918  typedef LoadNanoappRequest TableType;
919  uint32_t transaction_id;
920  uint64_t app_id;
921  uint32_t app_version;
922  uint32_t target_api_version;
923  std::vector<uint8_t> app_binary;
924  LoadNanoappRequestT()
925      : transaction_id(0),
926        app_id(0),
927        app_version(0),
928        target_api_version(0) {
929  }
930};
931
932struct LoadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
933  typedef LoadNanoappRequestT NativeTableType;
934  enum {
935    VT_TRANSACTION_ID = 4,
936    VT_APP_ID = 6,
937    VT_APP_VERSION = 8,
938    VT_TARGET_API_VERSION = 10,
939    VT_APP_BINARY = 12
940  };
941  uint32_t transaction_id() const {
942    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
943  }
944  bool mutate_transaction_id(uint32_t _transaction_id) {
945    return SetField(VT_TRANSACTION_ID, _transaction_id);
946  }
947  uint64_t app_id() const {
948    return GetField<uint64_t>(VT_APP_ID, 0);
949  }
950  bool mutate_app_id(uint64_t _app_id) {
951    return SetField(VT_APP_ID, _app_id);
952  }
953  uint32_t app_version() const {
954    return GetField<uint32_t>(VT_APP_VERSION, 0);
955  }
956  bool mutate_app_version(uint32_t _app_version) {
957    return SetField(VT_APP_VERSION, _app_version);
958  }
959  uint32_t target_api_version() const {
960    return GetField<uint32_t>(VT_TARGET_API_VERSION, 0);
961  }
962  bool mutate_target_api_version(uint32_t _target_api_version) {
963    return SetField(VT_TARGET_API_VERSION, _target_api_version);
964  }
965  const flatbuffers::Vector<uint8_t> *app_binary() const {
966    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
967  }
968  flatbuffers::Vector<uint8_t> *mutable_app_binary() {
969    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_APP_BINARY);
970  }
971  bool Verify(flatbuffers::Verifier &verifier) const {
972    return VerifyTableStart(verifier) &&
973           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
974           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
975           VerifyField<uint32_t>(verifier, VT_APP_VERSION) &&
976           VerifyField<uint32_t>(verifier, VT_TARGET_API_VERSION) &&
977           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_APP_BINARY) &&
978           verifier.Verify(app_binary()) &&
979           verifier.EndTable();
980  }
981  LoadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
982  void UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
983  static flatbuffers::Offset<LoadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
984};
985
986struct LoadNanoappRequestBuilder {
987  flatbuffers::FlatBufferBuilder &fbb_;
988  flatbuffers::uoffset_t start_;
989  void add_transaction_id(uint32_t transaction_id) {
990    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
991  }
992  void add_app_id(uint64_t app_id) {
993    fbb_.AddElement<uint64_t>(LoadNanoappRequest::VT_APP_ID, app_id, 0);
994  }
995  void add_app_version(uint32_t app_version) {
996    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_APP_VERSION, app_version, 0);
997  }
998  void add_target_api_version(uint32_t target_api_version) {
999    fbb_.AddElement<uint32_t>(LoadNanoappRequest::VT_TARGET_API_VERSION, target_api_version, 0);
1000  }
1001  void add_app_binary(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary) {
1002    fbb_.AddOffset(LoadNanoappRequest::VT_APP_BINARY, app_binary);
1003  }
1004  LoadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1005        : fbb_(_fbb) {
1006    start_ = fbb_.StartTable();
1007  }
1008  LoadNanoappRequestBuilder &operator=(const LoadNanoappRequestBuilder &);
1009  flatbuffers::Offset<LoadNanoappRequest> Finish() {
1010    const auto end = fbb_.EndTable(start_, 5);
1011    auto o = flatbuffers::Offset<LoadNanoappRequest>(end);
1012    fbb_.Required(o, LoadNanoappRequest::VT_APP_BINARY);
1013    return o;
1014  }
1015};
1016
1017inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(
1018    flatbuffers::FlatBufferBuilder &_fbb,
1019    uint32_t transaction_id = 0,
1020    uint64_t app_id = 0,
1021    uint32_t app_version = 0,
1022    uint32_t target_api_version = 0,
1023    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> app_binary = 0) {
1024  LoadNanoappRequestBuilder builder_(_fbb);
1025  builder_.add_app_id(app_id);
1026  builder_.add_app_binary(app_binary);
1027  builder_.add_target_api_version(target_api_version);
1028  builder_.add_app_version(app_version);
1029  builder_.add_transaction_id(transaction_id);
1030  return builder_.Finish();
1031}
1032
1033inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequestDirect(
1034    flatbuffers::FlatBufferBuilder &_fbb,
1035    uint32_t transaction_id = 0,
1036    uint64_t app_id = 0,
1037    uint32_t app_version = 0,
1038    uint32_t target_api_version = 0,
1039    const std::vector<uint8_t> *app_binary = nullptr) {
1040  return chre::fbs::CreateLoadNanoappRequest(
1041      _fbb,
1042      transaction_id,
1043      app_id,
1044      app_version,
1045      target_api_version,
1046      app_binary ? _fbb.CreateVector<uint8_t>(*app_binary) : 0);
1047}
1048
1049flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1050
1051struct LoadNanoappResponseT : public flatbuffers::NativeTable {
1052  typedef LoadNanoappResponse TableType;
1053  uint32_t transaction_id;
1054  bool success;
1055  LoadNanoappResponseT()
1056      : transaction_id(0),
1057        success(false) {
1058  }
1059};
1060
1061struct LoadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1062  typedef LoadNanoappResponseT NativeTableType;
1063  enum {
1064    VT_TRANSACTION_ID = 4,
1065    VT_SUCCESS = 6
1066  };
1067  uint32_t transaction_id() const {
1068    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1069  }
1070  bool mutate_transaction_id(uint32_t _transaction_id) {
1071    return SetField(VT_TRANSACTION_ID, _transaction_id);
1072  }
1073  bool success() const {
1074    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1075  }
1076  bool mutate_success(bool _success) {
1077    return SetField(VT_SUCCESS, static_cast<uint8_t>(_success));
1078  }
1079  bool Verify(flatbuffers::Verifier &verifier) const {
1080    return VerifyTableStart(verifier) &&
1081           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1082           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1083           verifier.EndTable();
1084  }
1085  LoadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1086  void UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1087  static flatbuffers::Offset<LoadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1088};
1089
1090struct LoadNanoappResponseBuilder {
1091  flatbuffers::FlatBufferBuilder &fbb_;
1092  flatbuffers::uoffset_t start_;
1093  void add_transaction_id(uint32_t transaction_id) {
1094    fbb_.AddElement<uint32_t>(LoadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
1095  }
1096  void add_success(bool success) {
1097    fbb_.AddElement<uint8_t>(LoadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1098  }
1099  LoadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1100        : fbb_(_fbb) {
1101    start_ = fbb_.StartTable();
1102  }
1103  LoadNanoappResponseBuilder &operator=(const LoadNanoappResponseBuilder &);
1104  flatbuffers::Offset<LoadNanoappResponse> Finish() {
1105    const auto end = fbb_.EndTable(start_, 2);
1106    auto o = flatbuffers::Offset<LoadNanoappResponse>(end);
1107    return o;
1108  }
1109};
1110
1111inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(
1112    flatbuffers::FlatBufferBuilder &_fbb,
1113    uint32_t transaction_id = 0,
1114    bool success = false) {
1115  LoadNanoappResponseBuilder builder_(_fbb);
1116  builder_.add_transaction_id(transaction_id);
1117  builder_.add_success(success);
1118  return builder_.Finish();
1119}
1120
1121flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1122
1123struct UnloadNanoappRequestT : public flatbuffers::NativeTable {
1124  typedef UnloadNanoappRequest TableType;
1125  uint32_t transaction_id;
1126  uint64_t app_id;
1127  bool allow_system_nanoapp_unload;
1128  UnloadNanoappRequestT()
1129      : transaction_id(0),
1130        app_id(0),
1131        allow_system_nanoapp_unload(false) {
1132  }
1133};
1134
1135struct UnloadNanoappRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1136  typedef UnloadNanoappRequestT NativeTableType;
1137  enum {
1138    VT_TRANSACTION_ID = 4,
1139    VT_APP_ID = 6,
1140    VT_ALLOW_SYSTEM_NANOAPP_UNLOAD = 8
1141  };
1142  uint32_t transaction_id() const {
1143    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1144  }
1145  bool mutate_transaction_id(uint32_t _transaction_id) {
1146    return SetField(VT_TRANSACTION_ID, _transaction_id);
1147  }
1148  uint64_t app_id() const {
1149    return GetField<uint64_t>(VT_APP_ID, 0);
1150  }
1151  bool mutate_app_id(uint64_t _app_id) {
1152    return SetField(VT_APP_ID, _app_id);
1153  }
1154  /// Set to true to allow this request to unload nanoapps identified as "system
1155  /// nanoapps", i.e. ones with is_system set to true in NanoappListResponse.
1156  bool allow_system_nanoapp_unload() const {
1157    return GetField<uint8_t>(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, 0) != 0;
1158  }
1159  bool mutate_allow_system_nanoapp_unload(bool _allow_system_nanoapp_unload) {
1160    return SetField(VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(_allow_system_nanoapp_unload));
1161  }
1162  bool Verify(flatbuffers::Verifier &verifier) const {
1163    return VerifyTableStart(verifier) &&
1164           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1165           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
1166           VerifyField<uint8_t>(verifier, VT_ALLOW_SYSTEM_NANOAPP_UNLOAD) &&
1167           verifier.EndTable();
1168  }
1169  UnloadNanoappRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1170  void UnPackTo(UnloadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1171  static flatbuffers::Offset<UnloadNanoappRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1172};
1173
1174struct UnloadNanoappRequestBuilder {
1175  flatbuffers::FlatBufferBuilder &fbb_;
1176  flatbuffers::uoffset_t start_;
1177  void add_transaction_id(uint32_t transaction_id) {
1178    fbb_.AddElement<uint32_t>(UnloadNanoappRequest::VT_TRANSACTION_ID, transaction_id, 0);
1179  }
1180  void add_app_id(uint64_t app_id) {
1181    fbb_.AddElement<uint64_t>(UnloadNanoappRequest::VT_APP_ID, app_id, 0);
1182  }
1183  void add_allow_system_nanoapp_unload(bool allow_system_nanoapp_unload) {
1184    fbb_.AddElement<uint8_t>(UnloadNanoappRequest::VT_ALLOW_SYSTEM_NANOAPP_UNLOAD, static_cast<uint8_t>(allow_system_nanoapp_unload), 0);
1185  }
1186  UnloadNanoappRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1187        : fbb_(_fbb) {
1188    start_ = fbb_.StartTable();
1189  }
1190  UnloadNanoappRequestBuilder &operator=(const UnloadNanoappRequestBuilder &);
1191  flatbuffers::Offset<UnloadNanoappRequest> Finish() {
1192    const auto end = fbb_.EndTable(start_, 3);
1193    auto o = flatbuffers::Offset<UnloadNanoappRequest>(end);
1194    return o;
1195  }
1196};
1197
1198inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(
1199    flatbuffers::FlatBufferBuilder &_fbb,
1200    uint32_t transaction_id = 0,
1201    uint64_t app_id = 0,
1202    bool allow_system_nanoapp_unload = false) {
1203  UnloadNanoappRequestBuilder builder_(_fbb);
1204  builder_.add_app_id(app_id);
1205  builder_.add_transaction_id(transaction_id);
1206  builder_.add_allow_system_nanoapp_unload(allow_system_nanoapp_unload);
1207  return builder_.Finish();
1208}
1209
1210flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1211
1212struct UnloadNanoappResponseT : public flatbuffers::NativeTable {
1213  typedef UnloadNanoappResponse TableType;
1214  uint32_t transaction_id;
1215  bool success;
1216  UnloadNanoappResponseT()
1217      : transaction_id(0),
1218        success(false) {
1219  }
1220};
1221
1222struct UnloadNanoappResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1223  typedef UnloadNanoappResponseT NativeTableType;
1224  enum {
1225    VT_TRANSACTION_ID = 4,
1226    VT_SUCCESS = 6
1227  };
1228  uint32_t transaction_id() const {
1229    return GetField<uint32_t>(VT_TRANSACTION_ID, 0);
1230  }
1231  bool mutate_transaction_id(uint32_t _transaction_id) {
1232    return SetField(VT_TRANSACTION_ID, _transaction_id);
1233  }
1234  bool success() const {
1235    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1236  }
1237  bool mutate_success(bool _success) {
1238    return SetField(VT_SUCCESS, static_cast<uint8_t>(_success));
1239  }
1240  bool Verify(flatbuffers::Verifier &verifier) const {
1241    return VerifyTableStart(verifier) &&
1242           VerifyField<uint32_t>(verifier, VT_TRANSACTION_ID) &&
1243           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1244           verifier.EndTable();
1245  }
1246  UnloadNanoappResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1247  void UnPackTo(UnloadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1248  static flatbuffers::Offset<UnloadNanoappResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1249};
1250
1251struct UnloadNanoappResponseBuilder {
1252  flatbuffers::FlatBufferBuilder &fbb_;
1253  flatbuffers::uoffset_t start_;
1254  void add_transaction_id(uint32_t transaction_id) {
1255    fbb_.AddElement<uint32_t>(UnloadNanoappResponse::VT_TRANSACTION_ID, transaction_id, 0);
1256  }
1257  void add_success(bool success) {
1258    fbb_.AddElement<uint8_t>(UnloadNanoappResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1259  }
1260  UnloadNanoappResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1261        : fbb_(_fbb) {
1262    start_ = fbb_.StartTable();
1263  }
1264  UnloadNanoappResponseBuilder &operator=(const UnloadNanoappResponseBuilder &);
1265  flatbuffers::Offset<UnloadNanoappResponse> Finish() {
1266    const auto end = fbb_.EndTable(start_, 2);
1267    auto o = flatbuffers::Offset<UnloadNanoappResponse>(end);
1268    return o;
1269  }
1270};
1271
1272inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(
1273    flatbuffers::FlatBufferBuilder &_fbb,
1274    uint32_t transaction_id = 0,
1275    bool success = false) {
1276  UnloadNanoappResponseBuilder builder_(_fbb);
1277  builder_.add_transaction_id(transaction_id);
1278  builder_.add_success(success);
1279  return builder_.Finish();
1280}
1281
1282flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1283
1284struct LogMessageT : public flatbuffers::NativeTable {
1285  typedef LogMessage TableType;
1286  std::vector<int8_t> buffer;
1287  LogMessageT() {
1288  }
1289};
1290
1291/// Represents log messages from CHRE.
1292struct LogMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1293  typedef LogMessageT NativeTableType;
1294  enum {
1295    VT_BUFFER = 4
1296  };
1297  /// A buffer containing formatted log data. A flat array is used here to avoid
1298  /// overhead in serializing and deserializing. The format is as follows:
1299  ///
1300  /// uint8_t                 - log level (1 = error, 2 = warning,
1301  ///                                      3 = info, 4 = debug)
1302  /// uint64_t, little-endian - timestamp in nanoseconds
1303  /// char[]                  - message to log
1304  /// char, \0                - null-terminator
1305  ///
1306  /// This pattern repeats until the end of the buffer for multiple log
1307  /// messages. The last byte will always be a null-terminator. There are no
1308  /// padding bytes between these fields. Treat this like a packed struct and be
1309  /// cautious with unaligned access when reading/writing this buffer.
1310  const flatbuffers::Vector<int8_t> *buffer() const {
1311    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_BUFFER);
1312  }
1313  flatbuffers::Vector<int8_t> *mutable_buffer() {
1314    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_BUFFER);
1315  }
1316  bool Verify(flatbuffers::Verifier &verifier) const {
1317    return VerifyTableStart(verifier) &&
1318           VerifyField<flatbuffers::uoffset_t>(verifier, VT_BUFFER) &&
1319           verifier.Verify(buffer()) &&
1320           verifier.EndTable();
1321  }
1322  LogMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1323  void UnPackTo(LogMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1324  static flatbuffers::Offset<LogMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1325};
1326
1327struct LogMessageBuilder {
1328  flatbuffers::FlatBufferBuilder &fbb_;
1329  flatbuffers::uoffset_t start_;
1330  void add_buffer(flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer) {
1331    fbb_.AddOffset(LogMessage::VT_BUFFER, buffer);
1332  }
1333  LogMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1334        : fbb_(_fbb) {
1335    start_ = fbb_.StartTable();
1336  }
1337  LogMessageBuilder &operator=(const LogMessageBuilder &);
1338  flatbuffers::Offset<LogMessage> Finish() {
1339    const auto end = fbb_.EndTable(start_, 1);
1340    auto o = flatbuffers::Offset<LogMessage>(end);
1341    return o;
1342  }
1343};
1344
1345inline flatbuffers::Offset<LogMessage> CreateLogMessage(
1346    flatbuffers::FlatBufferBuilder &_fbb,
1347    flatbuffers::Offset<flatbuffers::Vector<int8_t>> buffer = 0) {
1348  LogMessageBuilder builder_(_fbb);
1349  builder_.add_buffer(buffer);
1350  return builder_.Finish();
1351}
1352
1353inline flatbuffers::Offset<LogMessage> CreateLogMessageDirect(
1354    flatbuffers::FlatBufferBuilder &_fbb,
1355    const std::vector<int8_t> *buffer = nullptr) {
1356  return chre::fbs::CreateLogMessage(
1357      _fbb,
1358      buffer ? _fbb.CreateVector<int8_t>(*buffer) : 0);
1359}
1360
1361flatbuffers::Offset<LogMessage> CreateLogMessage(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1362
1363struct TimeSyncMessageT : public flatbuffers::NativeTable {
1364  typedef TimeSyncMessage TableType;
1365  int64_t offset;
1366  TimeSyncMessageT()
1367      : offset(0) {
1368  }
1369};
1370
1371/// Represents a message sent to CHRE to indicate AP timestamp for time sync
1372struct TimeSyncMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1373  typedef TimeSyncMessageT NativeTableType;
1374  enum {
1375    VT_OFFSET = 4
1376  };
1377  /// Offset between AP and CHRE timestamp
1378  int64_t offset() const {
1379    return GetField<int64_t>(VT_OFFSET, 0);
1380  }
1381  bool mutate_offset(int64_t _offset) {
1382    return SetField(VT_OFFSET, _offset);
1383  }
1384  bool Verify(flatbuffers::Verifier &verifier) const {
1385    return VerifyTableStart(verifier) &&
1386           VerifyField<int64_t>(verifier, VT_OFFSET) &&
1387           verifier.EndTable();
1388  }
1389  TimeSyncMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1390  void UnPackTo(TimeSyncMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1391  static flatbuffers::Offset<TimeSyncMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1392};
1393
1394struct TimeSyncMessageBuilder {
1395  flatbuffers::FlatBufferBuilder &fbb_;
1396  flatbuffers::uoffset_t start_;
1397  void add_offset(int64_t offset) {
1398    fbb_.AddElement<int64_t>(TimeSyncMessage::VT_OFFSET, offset, 0);
1399  }
1400  TimeSyncMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1401        : fbb_(_fbb) {
1402    start_ = fbb_.StartTable();
1403  }
1404  TimeSyncMessageBuilder &operator=(const TimeSyncMessageBuilder &);
1405  flatbuffers::Offset<TimeSyncMessage> Finish() {
1406    const auto end = fbb_.EndTable(start_, 1);
1407    auto o = flatbuffers::Offset<TimeSyncMessage>(end);
1408    return o;
1409  }
1410};
1411
1412inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(
1413    flatbuffers::FlatBufferBuilder &_fbb,
1414    int64_t offset = 0) {
1415  TimeSyncMessageBuilder builder_(_fbb);
1416  builder_.add_offset(offset);
1417  return builder_.Finish();
1418}
1419
1420flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1421
1422struct DebugDumpRequestT : public flatbuffers::NativeTable {
1423  typedef DebugDumpRequest TableType;
1424  DebugDumpRequestT() {
1425  }
1426};
1427
1428/// A request to gather and return debugging information. Only one debug dump
1429/// session can be active at a time. Upon accepting a request, zero or more
1430/// DebugDumpData messages are generated, followed by a DebugDumpResponse
1431/// indicating the completion of the operation.
1432struct DebugDumpRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1433  typedef DebugDumpRequestT NativeTableType;
1434  bool Verify(flatbuffers::Verifier &verifier) const {
1435    return VerifyTableStart(verifier) &&
1436           verifier.EndTable();
1437  }
1438  DebugDumpRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1439  void UnPackTo(DebugDumpRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1440  static flatbuffers::Offset<DebugDumpRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1441};
1442
1443struct DebugDumpRequestBuilder {
1444  flatbuffers::FlatBufferBuilder &fbb_;
1445  flatbuffers::uoffset_t start_;
1446  DebugDumpRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1447        : fbb_(_fbb) {
1448    start_ = fbb_.StartTable();
1449  }
1450  DebugDumpRequestBuilder &operator=(const DebugDumpRequestBuilder &);
1451  flatbuffers::Offset<DebugDumpRequest> Finish() {
1452    const auto end = fbb_.EndTable(start_, 0);
1453    auto o = flatbuffers::Offset<DebugDumpRequest>(end);
1454    return o;
1455  }
1456};
1457
1458inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(
1459    flatbuffers::FlatBufferBuilder &_fbb) {
1460  DebugDumpRequestBuilder builder_(_fbb);
1461  return builder_.Finish();
1462}
1463
1464flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1465
1466struct DebugDumpDataT : public flatbuffers::NativeTable {
1467  typedef DebugDumpData TableType;
1468  std::vector<int8_t> debug_str;
1469  DebugDumpDataT() {
1470  }
1471};
1472
1473struct DebugDumpData FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1474  typedef DebugDumpDataT NativeTableType;
1475  enum {
1476    VT_DEBUG_STR = 4
1477  };
1478  /// Null-terminated ASCII string containing debugging information
1479  const flatbuffers::Vector<int8_t> *debug_str() const {
1480    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR);
1481  }
1482  flatbuffers::Vector<int8_t> *mutable_debug_str() {
1483    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_DEBUG_STR);
1484  }
1485  bool Verify(flatbuffers::Verifier &verifier) const {
1486    return VerifyTableStart(verifier) &&
1487           VerifyField<flatbuffers::uoffset_t>(verifier, VT_DEBUG_STR) &&
1488           verifier.Verify(debug_str()) &&
1489           verifier.EndTable();
1490  }
1491  DebugDumpDataT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1492  void UnPackTo(DebugDumpDataT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1493  static flatbuffers::Offset<DebugDumpData> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1494};
1495
1496struct DebugDumpDataBuilder {
1497  flatbuffers::FlatBufferBuilder &fbb_;
1498  flatbuffers::uoffset_t start_;
1499  void add_debug_str(flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str) {
1500    fbb_.AddOffset(DebugDumpData::VT_DEBUG_STR, debug_str);
1501  }
1502  DebugDumpDataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1503        : fbb_(_fbb) {
1504    start_ = fbb_.StartTable();
1505  }
1506  DebugDumpDataBuilder &operator=(const DebugDumpDataBuilder &);
1507  flatbuffers::Offset<DebugDumpData> Finish() {
1508    const auto end = fbb_.EndTable(start_, 1);
1509    auto o = flatbuffers::Offset<DebugDumpData>(end);
1510    return o;
1511  }
1512};
1513
1514inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(
1515    flatbuffers::FlatBufferBuilder &_fbb,
1516    flatbuffers::Offset<flatbuffers::Vector<int8_t>> debug_str = 0) {
1517  DebugDumpDataBuilder builder_(_fbb);
1518  builder_.add_debug_str(debug_str);
1519  return builder_.Finish();
1520}
1521
1522inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpDataDirect(
1523    flatbuffers::FlatBufferBuilder &_fbb,
1524    const std::vector<int8_t> *debug_str = nullptr) {
1525  return chre::fbs::CreateDebugDumpData(
1526      _fbb,
1527      debug_str ? _fbb.CreateVector<int8_t>(*debug_str) : 0);
1528}
1529
1530flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1531
1532struct DebugDumpResponseT : public flatbuffers::NativeTable {
1533  typedef DebugDumpResponse TableType;
1534  bool success;
1535  uint32_t data_count;
1536  DebugDumpResponseT()
1537      : success(false),
1538        data_count(0) {
1539  }
1540};
1541
1542struct DebugDumpResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1543  typedef DebugDumpResponseT NativeTableType;
1544  enum {
1545    VT_SUCCESS = 4,
1546    VT_DATA_COUNT = 6
1547  };
1548  /// true if the request was accepted and a dump was performed, false if it was
1549  /// rejected or failed to complete for some reason
1550  bool success() const {
1551    return GetField<uint8_t>(VT_SUCCESS, 0) != 0;
1552  }
1553  bool mutate_success(bool _success) {
1554    return SetField(VT_SUCCESS, static_cast<uint8_t>(_success));
1555  }
1556  /// The number of DebugDumpData messages sent in this session
1557  uint32_t data_count() const {
1558    return GetField<uint32_t>(VT_DATA_COUNT, 0);
1559  }
1560  bool mutate_data_count(uint32_t _data_count) {
1561    return SetField(VT_DATA_COUNT, _data_count);
1562  }
1563  bool Verify(flatbuffers::Verifier &verifier) const {
1564    return VerifyTableStart(verifier) &&
1565           VerifyField<uint8_t>(verifier, VT_SUCCESS) &&
1566           VerifyField<uint32_t>(verifier, VT_DATA_COUNT) &&
1567           verifier.EndTable();
1568  }
1569  DebugDumpResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1570  void UnPackTo(DebugDumpResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1571  static flatbuffers::Offset<DebugDumpResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1572};
1573
1574struct DebugDumpResponseBuilder {
1575  flatbuffers::FlatBufferBuilder &fbb_;
1576  flatbuffers::uoffset_t start_;
1577  void add_success(bool success) {
1578    fbb_.AddElement<uint8_t>(DebugDumpResponse::VT_SUCCESS, static_cast<uint8_t>(success), 0);
1579  }
1580  void add_data_count(uint32_t data_count) {
1581    fbb_.AddElement<uint32_t>(DebugDumpResponse::VT_DATA_COUNT, data_count, 0);
1582  }
1583  DebugDumpResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1584        : fbb_(_fbb) {
1585    start_ = fbb_.StartTable();
1586  }
1587  DebugDumpResponseBuilder &operator=(const DebugDumpResponseBuilder &);
1588  flatbuffers::Offset<DebugDumpResponse> Finish() {
1589    const auto end = fbb_.EndTable(start_, 2);
1590    auto o = flatbuffers::Offset<DebugDumpResponse>(end);
1591    return o;
1592  }
1593};
1594
1595inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(
1596    flatbuffers::FlatBufferBuilder &_fbb,
1597    bool success = false,
1598    uint32_t data_count = 0) {
1599  DebugDumpResponseBuilder builder_(_fbb);
1600  builder_.add_data_count(data_count);
1601  builder_.add_success(success);
1602  return builder_.Finish();
1603}
1604
1605flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1606
1607struct MessageContainerT : public flatbuffers::NativeTable {
1608  typedef MessageContainer TableType;
1609  ChreMessageUnion message;
1610  std::unique_ptr<HostAddress> host_addr;
1611  MessageContainerT() {
1612  }
1613};
1614
1615/// The top-level container that encapsulates all possible messages. Note that
1616/// per FlatBuffers requirements, we can't use a union as the top-level
1617/// structure (root type), so we must wrap it in a table.
1618struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1619  typedef MessageContainerT NativeTableType;
1620  enum {
1621    VT_MESSAGE_TYPE = 4,
1622    VT_MESSAGE = 6,
1623    VT_HOST_ADDR = 8
1624  };
1625  ChreMessage message_type() const {
1626    return static_cast<ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
1627  }
1628  bool mutate_message_type(ChreMessage _message_type) {
1629    return SetField(VT_MESSAGE_TYPE, static_cast<uint8_t>(_message_type));
1630  }
1631  const void *message() const {
1632    return GetPointer<const void *>(VT_MESSAGE);
1633  }
1634  void *mutable_message() {
1635    return GetPointer<void *>(VT_MESSAGE);
1636  }
1637  /// The originating or destination client ID on the host side, used to direct
1638  /// responses only to the client that sent the request. Although initially
1639  /// populated by the requesting client, this is enforced to be the correct
1640  /// value by the entity guarding access to CHRE.
1641  /// This is wrapped in a struct to ensure that it is always included when
1642  /// encoding the message, so it can be mutated by the host daemon.
1643  const HostAddress *host_addr() const {
1644    return GetStruct<const HostAddress *>(VT_HOST_ADDR);
1645  }
1646  HostAddress *mutable_host_addr() {
1647    return GetStruct<HostAddress *>(VT_HOST_ADDR);
1648  }
1649  bool Verify(flatbuffers::Verifier &verifier) const {
1650    return VerifyTableStart(verifier) &&
1651           VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
1652           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
1653           VerifyChreMessage(verifier, message(), message_type()) &&
1654           VerifyFieldRequired<HostAddress>(verifier, VT_HOST_ADDR) &&
1655           verifier.EndTable();
1656  }
1657  MessageContainerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1658  void UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
1659  static flatbuffers::Offset<MessageContainer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1660};
1661
1662struct MessageContainerBuilder {
1663  flatbuffers::FlatBufferBuilder &fbb_;
1664  flatbuffers::uoffset_t start_;
1665  void add_message_type(ChreMessage message_type) {
1666    fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
1667  }
1668  void add_message(flatbuffers::Offset<void> message) {
1669    fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
1670  }
1671  void add_host_addr(const HostAddress *host_addr) {
1672    fbb_.AddStruct(MessageContainer::VT_HOST_ADDR, host_addr);
1673  }
1674  MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1675        : fbb_(_fbb) {
1676    start_ = fbb_.StartTable();
1677  }
1678  MessageContainerBuilder &operator=(const MessageContainerBuilder &);
1679  flatbuffers::Offset<MessageContainer> Finish() {
1680    const auto end = fbb_.EndTable(start_, 3);
1681    auto o = flatbuffers::Offset<MessageContainer>(end);
1682    fbb_.Required(o, MessageContainer::VT_MESSAGE);
1683    fbb_.Required(o, MessageContainer::VT_HOST_ADDR);
1684    return o;
1685  }
1686};
1687
1688inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
1689    flatbuffers::FlatBufferBuilder &_fbb,
1690    ChreMessage message_type = ChreMessage::NONE,
1691    flatbuffers::Offset<void> message = 0,
1692    const HostAddress *host_addr = 0) {
1693  MessageContainerBuilder builder_(_fbb);
1694  builder_.add_host_addr(host_addr);
1695  builder_.add_message(message);
1696  builder_.add_message_type(message_type);
1697  return builder_.Finish();
1698}
1699
1700flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
1701
1702inline NanoappMessageT *NanoappMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1703  auto _o = new NanoappMessageT();
1704  UnPackTo(_o, _resolver);
1705  return _o;
1706}
1707
1708inline void NanoappMessage::UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1709  (void)_o;
1710  (void)_resolver;
1711  { auto _e = app_id(); _o->app_id = _e; };
1712  { auto _e = message_type(); _o->message_type = _e; };
1713  { auto _e = host_endpoint(); _o->host_endpoint = _e; };
1714  { auto _e = message(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->message.push_back(_e->Get(_i)); } };
1715}
1716
1717inline flatbuffers::Offset<NanoappMessage> NanoappMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1718  return CreateNanoappMessage(_fbb, _o, _rehasher);
1719}
1720
1721inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1722  (void)_rehasher;
1723  (void)_o;
1724  auto _app_id = _o->app_id;
1725  auto _message_type = _o->message_type;
1726  auto _host_endpoint = _o->host_endpoint;
1727  auto _message = _fbb.CreateVector(_o->message);
1728  return chre::fbs::CreateNanoappMessage(
1729      _fbb,
1730      _app_id,
1731      _message_type,
1732      _host_endpoint,
1733      _message);
1734}
1735
1736inline HubInfoRequestT *HubInfoRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1737  auto _o = new HubInfoRequestT();
1738  UnPackTo(_o, _resolver);
1739  return _o;
1740}
1741
1742inline void HubInfoRequest::UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1743  (void)_o;
1744  (void)_resolver;
1745}
1746
1747inline flatbuffers::Offset<HubInfoRequest> HubInfoRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1748  return CreateHubInfoRequest(_fbb, _o, _rehasher);
1749}
1750
1751inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1752  (void)_rehasher;
1753  (void)_o;
1754  return chre::fbs::CreateHubInfoRequest(
1755      _fbb);
1756}
1757
1758inline HubInfoResponseT *HubInfoResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1759  auto _o = new HubInfoResponseT();
1760  UnPackTo(_o, _resolver);
1761  return _o;
1762}
1763
1764inline void HubInfoResponse::UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1765  (void)_o;
1766  (void)_resolver;
1767  { auto _e = name(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name.push_back(_e->Get(_i)); } };
1768  { auto _e = vendor(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vendor.push_back(_e->Get(_i)); } };
1769  { auto _e = toolchain(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->toolchain.push_back(_e->Get(_i)); } };
1770  { auto _e = platform_version(); _o->platform_version = _e; };
1771  { auto _e = toolchain_version(); _o->toolchain_version = _e; };
1772  { auto _e = peak_mips(); _o->peak_mips = _e; };
1773  { auto _e = stopped_power(); _o->stopped_power = _e; };
1774  { auto _e = sleep_power(); _o->sleep_power = _e; };
1775  { auto _e = peak_power(); _o->peak_power = _e; };
1776  { auto _e = max_msg_len(); _o->max_msg_len = _e; };
1777  { auto _e = platform_id(); _o->platform_id = _e; };
1778  { auto _e = chre_platform_version(); _o->chre_platform_version = _e; };
1779}
1780
1781inline flatbuffers::Offset<HubInfoResponse> HubInfoResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1782  return CreateHubInfoResponse(_fbb, _o, _rehasher);
1783}
1784
1785inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1786  (void)_rehasher;
1787  (void)_o;
1788  auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0;
1789  auto _vendor = _o->vendor.size() ? _fbb.CreateVector(_o->vendor) : 0;
1790  auto _toolchain = _o->toolchain.size() ? _fbb.CreateVector(_o->toolchain) : 0;
1791  auto _platform_version = _o->platform_version;
1792  auto _toolchain_version = _o->toolchain_version;
1793  auto _peak_mips = _o->peak_mips;
1794  auto _stopped_power = _o->stopped_power;
1795  auto _sleep_power = _o->sleep_power;
1796  auto _peak_power = _o->peak_power;
1797  auto _max_msg_len = _o->max_msg_len;
1798  auto _platform_id = _o->platform_id;
1799  auto _chre_platform_version = _o->chre_platform_version;
1800  return chre::fbs::CreateHubInfoResponse(
1801      _fbb,
1802      _name,
1803      _vendor,
1804      _toolchain,
1805      _platform_version,
1806      _toolchain_version,
1807      _peak_mips,
1808      _stopped_power,
1809      _sleep_power,
1810      _peak_power,
1811      _max_msg_len,
1812      _platform_id,
1813      _chre_platform_version);
1814}
1815
1816inline NanoappListRequestT *NanoappListRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1817  auto _o = new NanoappListRequestT();
1818  UnPackTo(_o, _resolver);
1819  return _o;
1820}
1821
1822inline void NanoappListRequest::UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1823  (void)_o;
1824  (void)_resolver;
1825}
1826
1827inline flatbuffers::Offset<NanoappListRequest> NanoappListRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1828  return CreateNanoappListRequest(_fbb, _o, _rehasher);
1829}
1830
1831inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1832  (void)_rehasher;
1833  (void)_o;
1834  return chre::fbs::CreateNanoappListRequest(
1835      _fbb);
1836}
1837
1838inline NanoappListEntryT *NanoappListEntry::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1839  auto _o = new NanoappListEntryT();
1840  UnPackTo(_o, _resolver);
1841  return _o;
1842}
1843
1844inline void NanoappListEntry::UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1845  (void)_o;
1846  (void)_resolver;
1847  { auto _e = app_id(); _o->app_id = _e; };
1848  { auto _e = version(); _o->version = _e; };
1849  { auto _e = enabled(); _o->enabled = _e; };
1850  { auto _e = is_system(); _o->is_system = _e; };
1851}
1852
1853inline flatbuffers::Offset<NanoappListEntry> NanoappListEntry::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1854  return CreateNanoappListEntry(_fbb, _o, _rehasher);
1855}
1856
1857inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1858  (void)_rehasher;
1859  (void)_o;
1860  auto _app_id = _o->app_id;
1861  auto _version = _o->version;
1862  auto _enabled = _o->enabled;
1863  auto _is_system = _o->is_system;
1864  return chre::fbs::CreateNanoappListEntry(
1865      _fbb,
1866      _app_id,
1867      _version,
1868      _enabled,
1869      _is_system);
1870}
1871
1872inline NanoappListResponseT *NanoappListResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1873  auto _o = new NanoappListResponseT();
1874  UnPackTo(_o, _resolver);
1875  return _o;
1876}
1877
1878inline void NanoappListResponse::UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1879  (void)_o;
1880  (void)_resolver;
1881  { 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))); } };
1882}
1883
1884inline flatbuffers::Offset<NanoappListResponse> NanoappListResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1885  return CreateNanoappListResponse(_fbb, _o, _rehasher);
1886}
1887
1888inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1889  (void)_rehasher;
1890  (void)_o;
1891  auto _nanoapps = _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(_o->nanoapps.size(), [&](size_t i) { return CreateNanoappListEntry(_fbb, _o->nanoapps[i].get(), _rehasher); });
1892  return chre::fbs::CreateNanoappListResponse(
1893      _fbb,
1894      _nanoapps);
1895}
1896
1897inline LoadNanoappRequestT *LoadNanoappRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1898  auto _o = new LoadNanoappRequestT();
1899  UnPackTo(_o, _resolver);
1900  return _o;
1901}
1902
1903inline void LoadNanoappRequest::UnPackTo(LoadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1904  (void)_o;
1905  (void)_resolver;
1906  { auto _e = transaction_id(); _o->transaction_id = _e; };
1907  { auto _e = app_id(); _o->app_id = _e; };
1908  { auto _e = app_version(); _o->app_version = _e; };
1909  { auto _e = target_api_version(); _o->target_api_version = _e; };
1910  { auto _e = app_binary(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->app_binary.push_back(_e->Get(_i)); } };
1911}
1912
1913inline flatbuffers::Offset<LoadNanoappRequest> LoadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1914  return CreateLoadNanoappRequest(_fbb, _o, _rehasher);
1915}
1916
1917inline flatbuffers::Offset<LoadNanoappRequest> CreateLoadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1918  (void)_rehasher;
1919  (void)_o;
1920  auto _transaction_id = _o->transaction_id;
1921  auto _app_id = _o->app_id;
1922  auto _app_version = _o->app_version;
1923  auto _target_api_version = _o->target_api_version;
1924  auto _app_binary = _fbb.CreateVector(_o->app_binary);
1925  return chre::fbs::CreateLoadNanoappRequest(
1926      _fbb,
1927      _transaction_id,
1928      _app_id,
1929      _app_version,
1930      _target_api_version,
1931      _app_binary);
1932}
1933
1934inline LoadNanoappResponseT *LoadNanoappResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1935  auto _o = new LoadNanoappResponseT();
1936  UnPackTo(_o, _resolver);
1937  return _o;
1938}
1939
1940inline void LoadNanoappResponse::UnPackTo(LoadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1941  (void)_o;
1942  (void)_resolver;
1943  { auto _e = transaction_id(); _o->transaction_id = _e; };
1944  { auto _e = success(); _o->success = _e; };
1945}
1946
1947inline flatbuffers::Offset<LoadNanoappResponse> LoadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1948  return CreateLoadNanoappResponse(_fbb, _o, _rehasher);
1949}
1950
1951inline flatbuffers::Offset<LoadNanoappResponse> CreateLoadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const LoadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1952  (void)_rehasher;
1953  (void)_o;
1954  auto _transaction_id = _o->transaction_id;
1955  auto _success = _o->success;
1956  return chre::fbs::CreateLoadNanoappResponse(
1957      _fbb,
1958      _transaction_id,
1959      _success);
1960}
1961
1962inline UnloadNanoappRequestT *UnloadNanoappRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1963  auto _o = new UnloadNanoappRequestT();
1964  UnPackTo(_o, _resolver);
1965  return _o;
1966}
1967
1968inline void UnloadNanoappRequest::UnPackTo(UnloadNanoappRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1969  (void)_o;
1970  (void)_resolver;
1971  { auto _e = transaction_id(); _o->transaction_id = _e; };
1972  { auto _e = app_id(); _o->app_id = _e; };
1973  { auto _e = allow_system_nanoapp_unload(); _o->allow_system_nanoapp_unload = _e; };
1974}
1975
1976inline flatbuffers::Offset<UnloadNanoappRequest> UnloadNanoappRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1977  return CreateUnloadNanoappRequest(_fbb, _o, _rehasher);
1978}
1979
1980inline flatbuffers::Offset<UnloadNanoappRequest> CreateUnloadNanoappRequest(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1981  (void)_rehasher;
1982  (void)_o;
1983  auto _transaction_id = _o->transaction_id;
1984  auto _app_id = _o->app_id;
1985  auto _allow_system_nanoapp_unload = _o->allow_system_nanoapp_unload;
1986  return chre::fbs::CreateUnloadNanoappRequest(
1987      _fbb,
1988      _transaction_id,
1989      _app_id,
1990      _allow_system_nanoapp_unload);
1991}
1992
1993inline UnloadNanoappResponseT *UnloadNanoappResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1994  auto _o = new UnloadNanoappResponseT();
1995  UnPackTo(_o, _resolver);
1996  return _o;
1997}
1998
1999inline void UnloadNanoappResponse::UnPackTo(UnloadNanoappResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2000  (void)_o;
2001  (void)_resolver;
2002  { auto _e = transaction_id(); _o->transaction_id = _e; };
2003  { auto _e = success(); _o->success = _e; };
2004}
2005
2006inline flatbuffers::Offset<UnloadNanoappResponse> UnloadNanoappResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2007  return CreateUnloadNanoappResponse(_fbb, _o, _rehasher);
2008}
2009
2010inline flatbuffers::Offset<UnloadNanoappResponse> CreateUnloadNanoappResponse(flatbuffers::FlatBufferBuilder &_fbb, const UnloadNanoappResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2011  (void)_rehasher;
2012  (void)_o;
2013  auto _transaction_id = _o->transaction_id;
2014  auto _success = _o->success;
2015  return chre::fbs::CreateUnloadNanoappResponse(
2016      _fbb,
2017      _transaction_id,
2018      _success);
2019}
2020
2021inline LogMessageT *LogMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2022  auto _o = new LogMessageT();
2023  UnPackTo(_o, _resolver);
2024  return _o;
2025}
2026
2027inline void LogMessage::UnPackTo(LogMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2028  (void)_o;
2029  (void)_resolver;
2030  { auto _e = buffer(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->buffer.push_back(_e->Get(_i)); } };
2031}
2032
2033inline flatbuffers::Offset<LogMessage> LogMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2034  return CreateLogMessage(_fbb, _o, _rehasher);
2035}
2036
2037inline flatbuffers::Offset<LogMessage> CreateLogMessage(flatbuffers::FlatBufferBuilder &_fbb, const LogMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2038  (void)_rehasher;
2039  (void)_o;
2040  auto _buffer = _o->buffer.size() ? _fbb.CreateVector(_o->buffer) : 0;
2041  return chre::fbs::CreateLogMessage(
2042      _fbb,
2043      _buffer);
2044}
2045
2046inline TimeSyncMessageT *TimeSyncMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2047  auto _o = new TimeSyncMessageT();
2048  UnPackTo(_o, _resolver);
2049  return _o;
2050}
2051
2052inline void TimeSyncMessage::UnPackTo(TimeSyncMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2053  (void)_o;
2054  (void)_resolver;
2055  { auto _e = offset(); _o->offset = _e; };
2056}
2057
2058inline flatbuffers::Offset<TimeSyncMessage> TimeSyncMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2059  return CreateTimeSyncMessage(_fbb, _o, _rehasher);
2060}
2061
2062inline flatbuffers::Offset<TimeSyncMessage> CreateTimeSyncMessage(flatbuffers::FlatBufferBuilder &_fbb, const TimeSyncMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2063  (void)_rehasher;
2064  (void)_o;
2065  auto _offset = _o->offset;
2066  return chre::fbs::CreateTimeSyncMessage(
2067      _fbb,
2068      _offset);
2069}
2070
2071inline DebugDumpRequestT *DebugDumpRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2072  auto _o = new DebugDumpRequestT();
2073  UnPackTo(_o, _resolver);
2074  return _o;
2075}
2076
2077inline void DebugDumpRequest::UnPackTo(DebugDumpRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2078  (void)_o;
2079  (void)_resolver;
2080}
2081
2082inline flatbuffers::Offset<DebugDumpRequest> DebugDumpRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2083  return CreateDebugDumpRequest(_fbb, _o, _rehasher);
2084}
2085
2086inline flatbuffers::Offset<DebugDumpRequest> CreateDebugDumpRequest(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2087  (void)_rehasher;
2088  (void)_o;
2089  return chre::fbs::CreateDebugDumpRequest(
2090      _fbb);
2091}
2092
2093inline DebugDumpDataT *DebugDumpData::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2094  auto _o = new DebugDumpDataT();
2095  UnPackTo(_o, _resolver);
2096  return _o;
2097}
2098
2099inline void DebugDumpData::UnPackTo(DebugDumpDataT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2100  (void)_o;
2101  (void)_resolver;
2102  { auto _e = debug_str(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->debug_str.push_back(_e->Get(_i)); } };
2103}
2104
2105inline flatbuffers::Offset<DebugDumpData> DebugDumpData::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2106  return CreateDebugDumpData(_fbb, _o, _rehasher);
2107}
2108
2109inline flatbuffers::Offset<DebugDumpData> CreateDebugDumpData(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpDataT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2110  (void)_rehasher;
2111  (void)_o;
2112  auto _debug_str = _o->debug_str.size() ? _fbb.CreateVector(_o->debug_str) : 0;
2113  return chre::fbs::CreateDebugDumpData(
2114      _fbb,
2115      _debug_str);
2116}
2117
2118inline DebugDumpResponseT *DebugDumpResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2119  auto _o = new DebugDumpResponseT();
2120  UnPackTo(_o, _resolver);
2121  return _o;
2122}
2123
2124inline void DebugDumpResponse::UnPackTo(DebugDumpResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2125  (void)_o;
2126  (void)_resolver;
2127  { auto _e = success(); _o->success = _e; };
2128  { auto _e = data_count(); _o->data_count = _e; };
2129}
2130
2131inline flatbuffers::Offset<DebugDumpResponse> DebugDumpResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2132  return CreateDebugDumpResponse(_fbb, _o, _rehasher);
2133}
2134
2135inline flatbuffers::Offset<DebugDumpResponse> CreateDebugDumpResponse(flatbuffers::FlatBufferBuilder &_fbb, const DebugDumpResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2136  (void)_rehasher;
2137  (void)_o;
2138  auto _success = _o->success;
2139  auto _data_count = _o->data_count;
2140  return chre::fbs::CreateDebugDumpResponse(
2141      _fbb,
2142      _success,
2143      _data_count);
2144}
2145
2146inline MessageContainerT *MessageContainer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
2147  auto _o = new MessageContainerT();
2148  UnPackTo(_o, _resolver);
2149  return _o;
2150}
2151
2152inline void MessageContainer::UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
2153  (void)_o;
2154  (void)_resolver;
2155  { auto _e = message_type(); _o->message.type = _e; };
2156  { auto _e = message(); if (_e) _o->message.table = ChreMessageUnion::UnPack(_e, message_type(),_resolver); };
2157  { auto _e = host_addr(); if (_e) _o->host_addr = std::unique_ptr<HostAddress>(new HostAddress(*_e)); };
2158}
2159
2160inline flatbuffers::Offset<MessageContainer> MessageContainer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
2161  return CreateMessageContainer(_fbb, _o, _rehasher);
2162}
2163
2164inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
2165  (void)_rehasher;
2166  (void)_o;
2167  auto _message_type = _o->message.type;
2168  auto _message = _o->message.Pack(_fbb);
2169  auto _host_addr = _o->host_addr ? _o->host_addr.get() : 0;
2170  return chre::fbs::CreateMessageContainer(
2171      _fbb,
2172      _message_type,
2173      _message,
2174      _host_addr);
2175}
2176
2177inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
2178  switch (type) {
2179    case ChreMessage::NONE: {
2180      return true;
2181    }
2182    case ChreMessage::NanoappMessage: {
2183      auto ptr = reinterpret_cast<const NanoappMessage *>(obj);
2184      return verifier.VerifyTable(ptr);
2185    }
2186    case ChreMessage::HubInfoRequest: {
2187      auto ptr = reinterpret_cast<const HubInfoRequest *>(obj);
2188      return verifier.VerifyTable(ptr);
2189    }
2190    case ChreMessage::HubInfoResponse: {
2191      auto ptr = reinterpret_cast<const HubInfoResponse *>(obj);
2192      return verifier.VerifyTable(ptr);
2193    }
2194    case ChreMessage::NanoappListRequest: {
2195      auto ptr = reinterpret_cast<const NanoappListRequest *>(obj);
2196      return verifier.VerifyTable(ptr);
2197    }
2198    case ChreMessage::NanoappListResponse: {
2199      auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
2200      return verifier.VerifyTable(ptr);
2201    }
2202    case ChreMessage::LoadNanoappRequest: {
2203      auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj);
2204      return verifier.VerifyTable(ptr);
2205    }
2206    case ChreMessage::LoadNanoappResponse: {
2207      auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj);
2208      return verifier.VerifyTable(ptr);
2209    }
2210    case ChreMessage::UnloadNanoappRequest: {
2211      auto ptr = reinterpret_cast<const UnloadNanoappRequest *>(obj);
2212      return verifier.VerifyTable(ptr);
2213    }
2214    case ChreMessage::UnloadNanoappResponse: {
2215      auto ptr = reinterpret_cast<const UnloadNanoappResponse *>(obj);
2216      return verifier.VerifyTable(ptr);
2217    }
2218    case ChreMessage::LogMessage: {
2219      auto ptr = reinterpret_cast<const LogMessage *>(obj);
2220      return verifier.VerifyTable(ptr);
2221    }
2222    case ChreMessage::TimeSyncMessage: {
2223      auto ptr = reinterpret_cast<const TimeSyncMessage *>(obj);
2224      return verifier.VerifyTable(ptr);
2225    }
2226    case ChreMessage::DebugDumpRequest: {
2227      auto ptr = reinterpret_cast<const DebugDumpRequest *>(obj);
2228      return verifier.VerifyTable(ptr);
2229    }
2230    case ChreMessage::DebugDumpData: {
2231      auto ptr = reinterpret_cast<const DebugDumpData *>(obj);
2232      return verifier.VerifyTable(ptr);
2233    }
2234    case ChreMessage::DebugDumpResponse: {
2235      auto ptr = reinterpret_cast<const DebugDumpResponse *>(obj);
2236      return verifier.VerifyTable(ptr);
2237    }
2238    default: return false;
2239  }
2240}
2241
2242inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2243  if (values->size() != types->size()) return false;
2244  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2245    if (!VerifyChreMessage(
2246        verifier,  values->Get(i), types->GetEnum<ChreMessage>(i))) {
2247      return false;
2248    }
2249  }
2250  return true;
2251}
2252
2253inline flatbuffers::NativeTable *ChreMessageUnion::UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver) {
2254  switch (type) {
2255    case ChreMessage::NanoappMessage: {
2256      auto ptr = reinterpret_cast<const NanoappMessage *>(obj);
2257      return ptr->UnPack(resolver);
2258    }
2259    case ChreMessage::HubInfoRequest: {
2260      auto ptr = reinterpret_cast<const HubInfoRequest *>(obj);
2261      return ptr->UnPack(resolver);
2262    }
2263    case ChreMessage::HubInfoResponse: {
2264      auto ptr = reinterpret_cast<const HubInfoResponse *>(obj);
2265      return ptr->UnPack(resolver);
2266    }
2267    case ChreMessage::NanoappListRequest: {
2268      auto ptr = reinterpret_cast<const NanoappListRequest *>(obj);
2269      return ptr->UnPack(resolver);
2270    }
2271    case ChreMessage::NanoappListResponse: {
2272      auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
2273      return ptr->UnPack(resolver);
2274    }
2275    case ChreMessage::LoadNanoappRequest: {
2276      auto ptr = reinterpret_cast<const LoadNanoappRequest *>(obj);
2277      return ptr->UnPack(resolver);
2278    }
2279    case ChreMessage::LoadNanoappResponse: {
2280      auto ptr = reinterpret_cast<const LoadNanoappResponse *>(obj);
2281      return ptr->UnPack(resolver);
2282    }
2283    case ChreMessage::UnloadNanoappRequest: {
2284      auto ptr = reinterpret_cast<const UnloadNanoappRequest *>(obj);
2285      return ptr->UnPack(resolver);
2286    }
2287    case ChreMessage::UnloadNanoappResponse: {
2288      auto ptr = reinterpret_cast<const UnloadNanoappResponse *>(obj);
2289      return ptr->UnPack(resolver);
2290    }
2291    case ChreMessage::LogMessage: {
2292      auto ptr = reinterpret_cast<const LogMessage *>(obj);
2293      return ptr->UnPack(resolver);
2294    }
2295    case ChreMessage::TimeSyncMessage: {
2296      auto ptr = reinterpret_cast<const TimeSyncMessage *>(obj);
2297      return ptr->UnPack(resolver);
2298    }
2299    case ChreMessage::DebugDumpRequest: {
2300      auto ptr = reinterpret_cast<const DebugDumpRequest *>(obj);
2301      return ptr->UnPack(resolver);
2302    }
2303    case ChreMessage::DebugDumpData: {
2304      auto ptr = reinterpret_cast<const DebugDumpData *>(obj);
2305      return ptr->UnPack(resolver);
2306    }
2307    case ChreMessage::DebugDumpResponse: {
2308      auto ptr = reinterpret_cast<const DebugDumpResponse *>(obj);
2309      return ptr->UnPack(resolver);
2310    }
2311    default: return nullptr;
2312  }
2313}
2314
2315inline flatbuffers::Offset<void> ChreMessageUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
2316  switch (type) {
2317    case ChreMessage::NanoappMessage: {
2318      auto ptr = reinterpret_cast<const NanoappMessageT *>(table);
2319      return CreateNanoappMessage(_fbb, ptr, _rehasher).Union();
2320    }
2321    case ChreMessage::HubInfoRequest: {
2322      auto ptr = reinterpret_cast<const HubInfoRequestT *>(table);
2323      return CreateHubInfoRequest(_fbb, ptr, _rehasher).Union();
2324    }
2325    case ChreMessage::HubInfoResponse: {
2326      auto ptr = reinterpret_cast<const HubInfoResponseT *>(table);
2327      return CreateHubInfoResponse(_fbb, ptr, _rehasher).Union();
2328    }
2329    case ChreMessage::NanoappListRequest: {
2330      auto ptr = reinterpret_cast<const NanoappListRequestT *>(table);
2331      return CreateNanoappListRequest(_fbb, ptr, _rehasher).Union();
2332    }
2333    case ChreMessage::NanoappListResponse: {
2334      auto ptr = reinterpret_cast<const NanoappListResponseT *>(table);
2335      return CreateNanoappListResponse(_fbb, ptr, _rehasher).Union();
2336    }
2337    case ChreMessage::LoadNanoappRequest: {
2338      auto ptr = reinterpret_cast<const LoadNanoappRequestT *>(table);
2339      return CreateLoadNanoappRequest(_fbb, ptr, _rehasher).Union();
2340    }
2341    case ChreMessage::LoadNanoappResponse: {
2342      auto ptr = reinterpret_cast<const LoadNanoappResponseT *>(table);
2343      return CreateLoadNanoappResponse(_fbb, ptr, _rehasher).Union();
2344    }
2345    case ChreMessage::UnloadNanoappRequest: {
2346      auto ptr = reinterpret_cast<const UnloadNanoappRequestT *>(table);
2347      return CreateUnloadNanoappRequest(_fbb, ptr, _rehasher).Union();
2348    }
2349    case ChreMessage::UnloadNanoappResponse: {
2350      auto ptr = reinterpret_cast<const UnloadNanoappResponseT *>(table);
2351      return CreateUnloadNanoappResponse(_fbb, ptr, _rehasher).Union();
2352    }
2353    case ChreMessage::LogMessage: {
2354      auto ptr = reinterpret_cast<const LogMessageT *>(table);
2355      return CreateLogMessage(_fbb, ptr, _rehasher).Union();
2356    }
2357    case ChreMessage::TimeSyncMessage: {
2358      auto ptr = reinterpret_cast<const TimeSyncMessageT *>(table);
2359      return CreateTimeSyncMessage(_fbb, ptr, _rehasher).Union();
2360    }
2361    case ChreMessage::DebugDumpRequest: {
2362      auto ptr = reinterpret_cast<const DebugDumpRequestT *>(table);
2363      return CreateDebugDumpRequest(_fbb, ptr, _rehasher).Union();
2364    }
2365    case ChreMessage::DebugDumpData: {
2366      auto ptr = reinterpret_cast<const DebugDumpDataT *>(table);
2367      return CreateDebugDumpData(_fbb, ptr, _rehasher).Union();
2368    }
2369    case ChreMessage::DebugDumpResponse: {
2370      auto ptr = reinterpret_cast<const DebugDumpResponseT *>(table);
2371      return CreateDebugDumpResponse(_fbb, ptr, _rehasher).Union();
2372    }
2373    default: return 0;
2374  }
2375}
2376
2377inline void ChreMessageUnion::Reset() {
2378  switch (type) {
2379    case ChreMessage::NanoappMessage: {
2380      auto ptr = reinterpret_cast<NanoappMessageT *>(table);
2381      delete ptr;
2382      break;
2383    }
2384    case ChreMessage::HubInfoRequest: {
2385      auto ptr = reinterpret_cast<HubInfoRequestT *>(table);
2386      delete ptr;
2387      break;
2388    }
2389    case ChreMessage::HubInfoResponse: {
2390      auto ptr = reinterpret_cast<HubInfoResponseT *>(table);
2391      delete ptr;
2392      break;
2393    }
2394    case ChreMessage::NanoappListRequest: {
2395      auto ptr = reinterpret_cast<NanoappListRequestT *>(table);
2396      delete ptr;
2397      break;
2398    }
2399    case ChreMessage::NanoappListResponse: {
2400      auto ptr = reinterpret_cast<NanoappListResponseT *>(table);
2401      delete ptr;
2402      break;
2403    }
2404    case ChreMessage::LoadNanoappRequest: {
2405      auto ptr = reinterpret_cast<LoadNanoappRequestT *>(table);
2406      delete ptr;
2407      break;
2408    }
2409    case ChreMessage::LoadNanoappResponse: {
2410      auto ptr = reinterpret_cast<LoadNanoappResponseT *>(table);
2411      delete ptr;
2412      break;
2413    }
2414    case ChreMessage::UnloadNanoappRequest: {
2415      auto ptr = reinterpret_cast<UnloadNanoappRequestT *>(table);
2416      delete ptr;
2417      break;
2418    }
2419    case ChreMessage::UnloadNanoappResponse: {
2420      auto ptr = reinterpret_cast<UnloadNanoappResponseT *>(table);
2421      delete ptr;
2422      break;
2423    }
2424    case ChreMessage::LogMessage: {
2425      auto ptr = reinterpret_cast<LogMessageT *>(table);
2426      delete ptr;
2427      break;
2428    }
2429    case ChreMessage::TimeSyncMessage: {
2430      auto ptr = reinterpret_cast<TimeSyncMessageT *>(table);
2431      delete ptr;
2432      break;
2433    }
2434    case ChreMessage::DebugDumpRequest: {
2435      auto ptr = reinterpret_cast<DebugDumpRequestT *>(table);
2436      delete ptr;
2437      break;
2438    }
2439    case ChreMessage::DebugDumpData: {
2440      auto ptr = reinterpret_cast<DebugDumpDataT *>(table);
2441      delete ptr;
2442      break;
2443    }
2444    case ChreMessage::DebugDumpResponse: {
2445      auto ptr = reinterpret_cast<DebugDumpResponseT *>(table);
2446      delete ptr;
2447      break;
2448    }
2449    default: break;
2450  }
2451  table = nullptr;
2452  type = ChreMessage::NONE;
2453}
2454
2455inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
2456  return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
2457}
2458
2459inline MessageContainer *GetMutableMessageContainer(void *buf) {
2460  return flatbuffers::GetMutableRoot<MessageContainer>(buf);
2461}
2462
2463inline bool VerifyMessageContainerBuffer(
2464    flatbuffers::Verifier &verifier) {
2465  return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
2466}
2467
2468inline void FinishMessageContainerBuffer(
2469    flatbuffers::FlatBufferBuilder &fbb,
2470    flatbuffers::Offset<chre::fbs::MessageContainer> root) {
2471  fbb.Finish(root);
2472}
2473
2474inline std::unique_ptr<MessageContainerT> UnPackMessageContainer(
2475    const void *buf,
2476    const flatbuffers::resolver_function_t *res = nullptr) {
2477  return std::unique_ptr<MessageContainerT>(GetMessageContainer(buf)->UnPack(res));
2478}
2479
2480}  // namespace fbs
2481}  // namespace chre
2482
2483#endif  // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
2484