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