host_messages_generated.h revision 07da7d6425058577d477074f99bafd4b8e81bb83 
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 MessageContainer;
31struct MessageContainerT;
32
33/// A union that joins together all possible messages. Note that in FlatBuffers,
34/// unions have an implicit type
35enum class ChreMessage : uint8_t {
36  NONE = 0,
37  NanoappMessage = 1,
38  HubInfoRequest = 2,
39  HubInfoResponse = 3,
40  NanoappListRequest = 4,
41  NanoappListResponse = 5,
42  MIN = NONE,
43  MAX = NanoappListResponse
44};
45
46inline const char **EnumNamesChreMessage() {
47  static const char *names[] = {
48    "NONE",
49    "NanoappMessage",
50    "HubInfoRequest",
51    "HubInfoResponse",
52    "NanoappListRequest",
53    "NanoappListResponse",
54    nullptr
55  };
56  return names;
57}
58
59inline const char *EnumNameChreMessage(ChreMessage e) {
60  const size_t index = static_cast<int>(e);
61  return EnumNamesChreMessage()[index];
62}
63
64template<typename T> struct ChreMessageTraits {
65  static const ChreMessage enum_value = ChreMessage::NONE;
66};
67
68template<> struct ChreMessageTraits<NanoappMessage> {
69  static const ChreMessage enum_value = ChreMessage::NanoappMessage;
70};
71
72template<> struct ChreMessageTraits<HubInfoRequest> {
73  static const ChreMessage enum_value = ChreMessage::HubInfoRequest;
74};
75
76template<> struct ChreMessageTraits<HubInfoResponse> {
77  static const ChreMessage enum_value = ChreMessage::HubInfoResponse;
78};
79
80template<> struct ChreMessageTraits<NanoappListRequest> {
81  static const ChreMessage enum_value = ChreMessage::NanoappListRequest;
82};
83
84template<> struct ChreMessageTraits<NanoappListResponse> {
85  static const ChreMessage enum_value = ChreMessage::NanoappListResponse;
86};
87
88struct ChreMessageUnion {
89  ChreMessage type;
90  flatbuffers::NativeTable *table;
91
92  ChreMessageUnion() : type(ChreMessage::NONE), table(nullptr) {}
93  ChreMessageUnion(ChreMessageUnion&& u):
94    type(std::move(u.type)), table(std::move(u.table)) {}
95  ChreMessageUnion(const ChreMessageUnion &);
96  ChreMessageUnion &operator=(const ChreMessageUnion &);
97  ~ChreMessageUnion() { Reset(); }
98
99  void Reset();
100
101  template <typename T>
102  void Set(T&& value) {
103    Reset();
104    type = ChreMessageTraits<typename T::TableType>::enum_value;
105    if (type != ChreMessage::NONE) {
106      table = new T(std::forward<T>(value));
107    }
108  }
109
110  static flatbuffers::NativeTable *UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver);
111  flatbuffers::Offset<void> Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher = nullptr) const;
112
113  NanoappMessageT *AsNanoappMessage() {
114    return type == ChreMessage::NanoappMessage ?
115      reinterpret_cast<NanoappMessageT *>(table) : nullptr;
116  }
117  HubInfoRequestT *AsHubInfoRequest() {
118    return type == ChreMessage::HubInfoRequest ?
119      reinterpret_cast<HubInfoRequestT *>(table) : nullptr;
120  }
121  HubInfoResponseT *AsHubInfoResponse() {
122    return type == ChreMessage::HubInfoResponse ?
123      reinterpret_cast<HubInfoResponseT *>(table) : nullptr;
124  }
125  NanoappListRequestT *AsNanoappListRequest() {
126    return type == ChreMessage::NanoappListRequest ?
127      reinterpret_cast<NanoappListRequestT *>(table) : nullptr;
128  }
129  NanoappListResponseT *AsNanoappListResponse() {
130    return type == ChreMessage::NanoappListResponse ?
131      reinterpret_cast<NanoappListResponseT *>(table) : nullptr;
132  }
133};
134
135bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type);
136bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
137
138struct NanoappMessageT : public flatbuffers::NativeTable {
139  typedef NanoappMessage TableType;
140  uint64_t app_id;
141  uint32_t message_type;
142  uint16_t host_endpoint;
143  std::vector<uint8_t> message;
144  NanoappMessageT()
145      : app_id(0),
146        message_type(0),
147        host_endpoint(65534) {
148  }
149};
150
151/// Represents a message sent to/from a nanoapp from/to a client on the host
152struct NanoappMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
153  typedef NanoappMessageT NativeTableType;
154  enum {
155    VT_APP_ID = 4,
156    VT_MESSAGE_TYPE = 6,
157    VT_HOST_ENDPOINT = 8,
158    VT_MESSAGE = 10
159  };
160  uint64_t app_id() const {
161    return GetField<uint64_t>(VT_APP_ID, 0);
162  }
163  bool mutate_app_id(uint64_t _app_id) {
164    return SetField(VT_APP_ID, _app_id);
165  }
166  uint32_t message_type() const {
167    return GetField<uint32_t>(VT_MESSAGE_TYPE, 0);
168  }
169  bool mutate_message_type(uint32_t _message_type) {
170    return SetField(VT_MESSAGE_TYPE, _message_type);
171  }
172  /// Identifies the host-side endpoint on the host that sent or should receive
173  /// this message. The default value is a special value defined in the HAL and
174  /// elsewhere that indicates that the endpoint is unspecified.
175  uint16_t host_endpoint() const {
176    return GetField<uint16_t>(VT_HOST_ENDPOINT, 65534);
177  }
178  bool mutate_host_endpoint(uint16_t _host_endpoint) {
179    return SetField(VT_HOST_ENDPOINT, _host_endpoint);
180  }
181  /// Vector containing arbitrary application-specific message data
182  const flatbuffers::Vector<uint8_t> *message() const {
183    return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
184  }
185  flatbuffers::Vector<uint8_t> *mutable_message() {
186    return GetPointer<flatbuffers::Vector<uint8_t> *>(VT_MESSAGE);
187  }
188  bool Verify(flatbuffers::Verifier &verifier) const {
189    return VerifyTableStart(verifier) &&
190           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
191           VerifyField<uint32_t>(verifier, VT_MESSAGE_TYPE) &&
192           VerifyField<uint16_t>(verifier, VT_HOST_ENDPOINT) &&
193           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
194           verifier.Verify(message()) &&
195           verifier.EndTable();
196  }
197  NanoappMessageT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
198  void UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
199  static flatbuffers::Offset<NanoappMessage> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
200};
201
202struct NanoappMessageBuilder {
203  flatbuffers::FlatBufferBuilder &fbb_;
204  flatbuffers::uoffset_t start_;
205  void add_app_id(uint64_t app_id) {
206    fbb_.AddElement<uint64_t>(NanoappMessage::VT_APP_ID, app_id, 0);
207  }
208  void add_message_type(uint32_t message_type) {
209    fbb_.AddElement<uint32_t>(NanoappMessage::VT_MESSAGE_TYPE, message_type, 0);
210  }
211  void add_host_endpoint(uint16_t host_endpoint) {
212    fbb_.AddElement<uint16_t>(NanoappMessage::VT_HOST_ENDPOINT, host_endpoint, 65534);
213  }
214  void add_message(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message) {
215    fbb_.AddOffset(NanoappMessage::VT_MESSAGE, message);
216  }
217  NanoappMessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
218        : fbb_(_fbb) {
219    start_ = fbb_.StartTable();
220  }
221  NanoappMessageBuilder &operator=(const NanoappMessageBuilder &);
222  flatbuffers::Offset<NanoappMessage> Finish() {
223    const auto end = fbb_.EndTable(start_, 4);
224    auto o = flatbuffers::Offset<NanoappMessage>(end);
225    fbb_.Required(o, NanoappMessage::VT_MESSAGE);
226    return o;
227  }
228};
229
230inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(
231    flatbuffers::FlatBufferBuilder &_fbb,
232    uint64_t app_id = 0,
233    uint32_t message_type = 0,
234    uint16_t host_endpoint = 65534,
235    flatbuffers::Offset<flatbuffers::Vector<uint8_t>> message = 0) {
236  NanoappMessageBuilder builder_(_fbb);
237  builder_.add_app_id(app_id);
238  builder_.add_message(message);
239  builder_.add_message_type(message_type);
240  builder_.add_host_endpoint(host_endpoint);
241  return builder_.Finish();
242}
243
244inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessageDirect(
245    flatbuffers::FlatBufferBuilder &_fbb,
246    uint64_t app_id = 0,
247    uint32_t message_type = 0,
248    uint16_t host_endpoint = 65534,
249    const std::vector<uint8_t> *message = nullptr) {
250  return chre::fbs::CreateNanoappMessage(
251      _fbb,
252      app_id,
253      message_type,
254      host_endpoint,
255      message ? _fbb.CreateVector<uint8_t>(*message) : 0);
256}
257
258flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
259
260struct HubInfoRequestT : public flatbuffers::NativeTable {
261  typedef HubInfoRequest TableType;
262  HubInfoRequestT() {
263  }
264};
265
266struct HubInfoRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
267  typedef HubInfoRequestT NativeTableType;
268  bool Verify(flatbuffers::Verifier &verifier) const {
269    return VerifyTableStart(verifier) &&
270           verifier.EndTable();
271  }
272  HubInfoRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
273  void UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
274  static flatbuffers::Offset<HubInfoRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
275};
276
277struct HubInfoRequestBuilder {
278  flatbuffers::FlatBufferBuilder &fbb_;
279  flatbuffers::uoffset_t start_;
280  HubInfoRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
281        : fbb_(_fbb) {
282    start_ = fbb_.StartTable();
283  }
284  HubInfoRequestBuilder &operator=(const HubInfoRequestBuilder &);
285  flatbuffers::Offset<HubInfoRequest> Finish() {
286    const auto end = fbb_.EndTable(start_, 0);
287    auto o = flatbuffers::Offset<HubInfoRequest>(end);
288    return o;
289  }
290};
291
292inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(
293    flatbuffers::FlatBufferBuilder &_fbb) {
294  HubInfoRequestBuilder builder_(_fbb);
295  return builder_.Finish();
296}
297
298flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
299
300struct HubInfoResponseT : public flatbuffers::NativeTable {
301  typedef HubInfoResponse TableType;
302  std::vector<int8_t> name;
303  std::vector<int8_t> vendor;
304  std::vector<int8_t> toolchain;
305  uint32_t platform_version;
306  uint32_t toolchain_version;
307  float peak_mips;
308  float stopped_power;
309  float sleep_power;
310  float peak_power;
311  uint32_t max_msg_len;
312  uint64_t platform_id;
313  uint32_t chre_platform_version;
314  HubInfoResponseT()
315      : platform_version(0),
316        toolchain_version(0),
317        peak_mips(0.0f),
318        stopped_power(0.0f),
319        sleep_power(0.0f),
320        peak_power(0.0f),
321        max_msg_len(0),
322        platform_id(0),
323        chre_platform_version(0) {
324  }
325};
326
327struct HubInfoResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
328  typedef HubInfoResponseT NativeTableType;
329  enum {
330    VT_NAME = 4,
331    VT_VENDOR = 6,
332    VT_TOOLCHAIN = 8,
333    VT_PLATFORM_VERSION = 10,
334    VT_TOOLCHAIN_VERSION = 12,
335    VT_PEAK_MIPS = 14,
336    VT_STOPPED_POWER = 16,
337    VT_SLEEP_POWER = 18,
338    VT_PEAK_POWER = 20,
339    VT_MAX_MSG_LEN = 22,
340    VT_PLATFORM_ID = 24,
341    VT_CHRE_PLATFORM_VERSION = 26
342  };
343  /// The name of the hub. Nominally a UTF-8 string, but note that we're not
344  /// using the built-in "string" data type from FlatBuffers here, because the
345  /// generated C++ uses std::string which is not well-supported in CHRE. This
346  /// applies for vendor and toolchain as well.
347  const flatbuffers::Vector<int8_t> *name() const {
348    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_NAME);
349  }
350  flatbuffers::Vector<int8_t> *mutable_name() {
351    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_NAME);
352  }
353  const flatbuffers::Vector<int8_t> *vendor() const {
354    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_VENDOR);
355  }
356  flatbuffers::Vector<int8_t> *mutable_vendor() {
357    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_VENDOR);
358  }
359  const flatbuffers::Vector<int8_t> *toolchain() const {
360    return GetPointer<const flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
361  }
362  flatbuffers::Vector<int8_t> *mutable_toolchain() {
363    return GetPointer<flatbuffers::Vector<int8_t> *>(VT_TOOLCHAIN);
364  }
365  /// Legacy platform version reported in the HAL; semantics not strictly
366  /// defined
367  uint32_t platform_version() const {
368    return GetField<uint32_t>(VT_PLATFORM_VERSION, 0);
369  }
370  bool mutate_platform_version(uint32_t _platform_version) {
371    return SetField(VT_PLATFORM_VERSION, _platform_version);
372  }
373  /// Toolchain version reported in the HAL; semantics not strictly defined
374  uint32_t toolchain_version() const {
375    return GetField<uint32_t>(VT_TOOLCHAIN_VERSION, 0);
376  }
377  bool mutate_toolchain_version(uint32_t _toolchain_version) {
378    return SetField(VT_TOOLCHAIN_VERSION, _toolchain_version);
379  }
380  float peak_mips() const {
381    return GetField<float>(VT_PEAK_MIPS, 0.0f);
382  }
383  bool mutate_peak_mips(float _peak_mips) {
384    return SetField(VT_PEAK_MIPS, _peak_mips);
385  }
386  float stopped_power() const {
387    return GetField<float>(VT_STOPPED_POWER, 0.0f);
388  }
389  bool mutate_stopped_power(float _stopped_power) {
390    return SetField(VT_STOPPED_POWER, _stopped_power);
391  }
392  float sleep_power() const {
393    return GetField<float>(VT_SLEEP_POWER, 0.0f);
394  }
395  bool mutate_sleep_power(float _sleep_power) {
396    return SetField(VT_SLEEP_POWER, _sleep_power);
397  }
398  float peak_power() const {
399    return GetField<float>(VT_PEAK_POWER, 0.0f);
400  }
401  bool mutate_peak_power(float _peak_power) {
402    return SetField(VT_PEAK_POWER, _peak_power);
403  }
404  /// Maximum size message that can be sent to a nanoapp
405  uint32_t max_msg_len() const {
406    return GetField<uint32_t>(VT_MAX_MSG_LEN, 0);
407  }
408  bool mutate_max_msg_len(uint32_t _max_msg_len) {
409    return SetField(VT_MAX_MSG_LEN, _max_msg_len);
410  }
411  /// @see chreGetPlatformId()
412  uint64_t platform_id() const {
413    return GetField<uint64_t>(VT_PLATFORM_ID, 0);
414  }
415  bool mutate_platform_id(uint64_t _platform_id) {
416    return SetField(VT_PLATFORM_ID, _platform_id);
417  }
418  /// @see chreGetVersion()
419  uint32_t chre_platform_version() const {
420    return GetField<uint32_t>(VT_CHRE_PLATFORM_VERSION, 0);
421  }
422  bool mutate_chre_platform_version(uint32_t _chre_platform_version) {
423    return SetField(VT_CHRE_PLATFORM_VERSION, _chre_platform_version);
424  }
425  bool Verify(flatbuffers::Verifier &verifier) const {
426    return VerifyTableStart(verifier) &&
427           VerifyField<flatbuffers::uoffset_t>(verifier, VT_NAME) &&
428           verifier.Verify(name()) &&
429           VerifyField<flatbuffers::uoffset_t>(verifier, VT_VENDOR) &&
430           verifier.Verify(vendor()) &&
431           VerifyField<flatbuffers::uoffset_t>(verifier, VT_TOOLCHAIN) &&
432           verifier.Verify(toolchain()) &&
433           VerifyField<uint32_t>(verifier, VT_PLATFORM_VERSION) &&
434           VerifyField<uint32_t>(verifier, VT_TOOLCHAIN_VERSION) &&
435           VerifyField<float>(verifier, VT_PEAK_MIPS) &&
436           VerifyField<float>(verifier, VT_STOPPED_POWER) &&
437           VerifyField<float>(verifier, VT_SLEEP_POWER) &&
438           VerifyField<float>(verifier, VT_PEAK_POWER) &&
439           VerifyField<uint32_t>(verifier, VT_MAX_MSG_LEN) &&
440           VerifyField<uint64_t>(verifier, VT_PLATFORM_ID) &&
441           VerifyField<uint32_t>(verifier, VT_CHRE_PLATFORM_VERSION) &&
442           verifier.EndTable();
443  }
444  HubInfoResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
445  void UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
446  static flatbuffers::Offset<HubInfoResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
447};
448
449struct HubInfoResponseBuilder {
450  flatbuffers::FlatBufferBuilder &fbb_;
451  flatbuffers::uoffset_t start_;
452  void add_name(flatbuffers::Offset<flatbuffers::Vector<int8_t>> name) {
453    fbb_.AddOffset(HubInfoResponse::VT_NAME, name);
454  }
455  void add_vendor(flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor) {
456    fbb_.AddOffset(HubInfoResponse::VT_VENDOR, vendor);
457  }
458  void add_toolchain(flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain) {
459    fbb_.AddOffset(HubInfoResponse::VT_TOOLCHAIN, toolchain);
460  }
461  void add_platform_version(uint32_t platform_version) {
462    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_PLATFORM_VERSION, platform_version, 0);
463  }
464  void add_toolchain_version(uint32_t toolchain_version) {
465    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_TOOLCHAIN_VERSION, toolchain_version, 0);
466  }
467  void add_peak_mips(float peak_mips) {
468    fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_MIPS, peak_mips, 0.0f);
469  }
470  void add_stopped_power(float stopped_power) {
471    fbb_.AddElement<float>(HubInfoResponse::VT_STOPPED_POWER, stopped_power, 0.0f);
472  }
473  void add_sleep_power(float sleep_power) {
474    fbb_.AddElement<float>(HubInfoResponse::VT_SLEEP_POWER, sleep_power, 0.0f);
475  }
476  void add_peak_power(float peak_power) {
477    fbb_.AddElement<float>(HubInfoResponse::VT_PEAK_POWER, peak_power, 0.0f);
478  }
479  void add_max_msg_len(uint32_t max_msg_len) {
480    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_MAX_MSG_LEN, max_msg_len, 0);
481  }
482  void add_platform_id(uint64_t platform_id) {
483    fbb_.AddElement<uint64_t>(HubInfoResponse::VT_PLATFORM_ID, platform_id, 0);
484  }
485  void add_chre_platform_version(uint32_t chre_platform_version) {
486    fbb_.AddElement<uint32_t>(HubInfoResponse::VT_CHRE_PLATFORM_VERSION, chre_platform_version, 0);
487  }
488  HubInfoResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
489        : fbb_(_fbb) {
490    start_ = fbb_.StartTable();
491  }
492  HubInfoResponseBuilder &operator=(const HubInfoResponseBuilder &);
493  flatbuffers::Offset<HubInfoResponse> Finish() {
494    const auto end = fbb_.EndTable(start_, 12);
495    auto o = flatbuffers::Offset<HubInfoResponse>(end);
496    return o;
497  }
498};
499
500inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(
501    flatbuffers::FlatBufferBuilder &_fbb,
502    flatbuffers::Offset<flatbuffers::Vector<int8_t>> name = 0,
503    flatbuffers::Offset<flatbuffers::Vector<int8_t>> vendor = 0,
504    flatbuffers::Offset<flatbuffers::Vector<int8_t>> toolchain = 0,
505    uint32_t platform_version = 0,
506    uint32_t toolchain_version = 0,
507    float peak_mips = 0.0f,
508    float stopped_power = 0.0f,
509    float sleep_power = 0.0f,
510    float peak_power = 0.0f,
511    uint32_t max_msg_len = 0,
512    uint64_t platform_id = 0,
513    uint32_t chre_platform_version = 0) {
514  HubInfoResponseBuilder builder_(_fbb);
515  builder_.add_platform_id(platform_id);
516  builder_.add_chre_platform_version(chre_platform_version);
517  builder_.add_max_msg_len(max_msg_len);
518  builder_.add_peak_power(peak_power);
519  builder_.add_sleep_power(sleep_power);
520  builder_.add_stopped_power(stopped_power);
521  builder_.add_peak_mips(peak_mips);
522  builder_.add_toolchain_version(toolchain_version);
523  builder_.add_platform_version(platform_version);
524  builder_.add_toolchain(toolchain);
525  builder_.add_vendor(vendor);
526  builder_.add_name(name);
527  return builder_.Finish();
528}
529
530inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponseDirect(
531    flatbuffers::FlatBufferBuilder &_fbb,
532    const std::vector<int8_t> *name = nullptr,
533    const std::vector<int8_t> *vendor = nullptr,
534    const std::vector<int8_t> *toolchain = nullptr,
535    uint32_t platform_version = 0,
536    uint32_t toolchain_version = 0,
537    float peak_mips = 0.0f,
538    float stopped_power = 0.0f,
539    float sleep_power = 0.0f,
540    float peak_power = 0.0f,
541    uint32_t max_msg_len = 0,
542    uint64_t platform_id = 0,
543    uint32_t chre_platform_version = 0) {
544  return chre::fbs::CreateHubInfoResponse(
545      _fbb,
546      name ? _fbb.CreateVector<int8_t>(*name) : 0,
547      vendor ? _fbb.CreateVector<int8_t>(*vendor) : 0,
548      toolchain ? _fbb.CreateVector<int8_t>(*toolchain) : 0,
549      platform_version,
550      toolchain_version,
551      peak_mips,
552      stopped_power,
553      sleep_power,
554      peak_power,
555      max_msg_len,
556      platform_id,
557      chre_platform_version);
558}
559
560flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
561
562struct NanoappListRequestT : public flatbuffers::NativeTable {
563  typedef NanoappListRequest TableType;
564  NanoappListRequestT() {
565  }
566};
567
568struct NanoappListRequest FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
569  typedef NanoappListRequestT NativeTableType;
570  bool Verify(flatbuffers::Verifier &verifier) const {
571    return VerifyTableStart(verifier) &&
572           verifier.EndTable();
573  }
574  NanoappListRequestT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
575  void UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
576  static flatbuffers::Offset<NanoappListRequest> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
577};
578
579struct NanoappListRequestBuilder {
580  flatbuffers::FlatBufferBuilder &fbb_;
581  flatbuffers::uoffset_t start_;
582  NanoappListRequestBuilder(flatbuffers::FlatBufferBuilder &_fbb)
583        : fbb_(_fbb) {
584    start_ = fbb_.StartTable();
585  }
586  NanoappListRequestBuilder &operator=(const NanoappListRequestBuilder &);
587  flatbuffers::Offset<NanoappListRequest> Finish() {
588    const auto end = fbb_.EndTable(start_, 0);
589    auto o = flatbuffers::Offset<NanoappListRequest>(end);
590    return o;
591  }
592};
593
594inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(
595    flatbuffers::FlatBufferBuilder &_fbb) {
596  NanoappListRequestBuilder builder_(_fbb);
597  return builder_.Finish();
598}
599
600flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
601
602struct NanoappListEntryT : public flatbuffers::NativeTable {
603  typedef NanoappListEntry TableType;
604  uint64_t app_id;
605  uint32_t version;
606  bool enabled;
607  bool is_system;
608  NanoappListEntryT()
609      : app_id(0),
610        version(0),
611        enabled(true),
612        is_system(false) {
613  }
614};
615
616struct NanoappListEntry FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
617  typedef NanoappListEntryT NativeTableType;
618  enum {
619    VT_APP_ID = 4,
620    VT_VERSION = 6,
621    VT_ENABLED = 8,
622    VT_IS_SYSTEM = 10
623  };
624  uint64_t app_id() const {
625    return GetField<uint64_t>(VT_APP_ID, 0);
626  }
627  bool mutate_app_id(uint64_t _app_id) {
628    return SetField(VT_APP_ID, _app_id);
629  }
630  uint32_t version() const {
631    return GetField<uint32_t>(VT_VERSION, 0);
632  }
633  bool mutate_version(uint32_t _version) {
634    return SetField(VT_VERSION, _version);
635  }
636  bool enabled() const {
637    return GetField<uint8_t>(VT_ENABLED, 1) != 0;
638  }
639  bool mutate_enabled(bool _enabled) {
640    return SetField(VT_ENABLED, static_cast<uint8_t>(_enabled));
641  }
642  /// Whether the nanoapp is a pre-loaded "system" nanoapp, i.e. one that should
643  /// not show up in the list of nanoapps in the context hub HAL. System
644  /// nanoapps are typically used to leverage CHRE for some device functionality
645  /// and do not interact via the context hub HAL.
646  bool is_system() const {
647    return GetField<uint8_t>(VT_IS_SYSTEM, 0) != 0;
648  }
649  bool mutate_is_system(bool _is_system) {
650    return SetField(VT_IS_SYSTEM, static_cast<uint8_t>(_is_system));
651  }
652  bool Verify(flatbuffers::Verifier &verifier) const {
653    return VerifyTableStart(verifier) &&
654           VerifyField<uint64_t>(verifier, VT_APP_ID) &&
655           VerifyField<uint32_t>(verifier, VT_VERSION) &&
656           VerifyField<uint8_t>(verifier, VT_ENABLED) &&
657           VerifyField<uint8_t>(verifier, VT_IS_SYSTEM) &&
658           verifier.EndTable();
659  }
660  NanoappListEntryT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
661  void UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
662  static flatbuffers::Offset<NanoappListEntry> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
663};
664
665struct NanoappListEntryBuilder {
666  flatbuffers::FlatBufferBuilder &fbb_;
667  flatbuffers::uoffset_t start_;
668  void add_app_id(uint64_t app_id) {
669    fbb_.AddElement<uint64_t>(NanoappListEntry::VT_APP_ID, app_id, 0);
670  }
671  void add_version(uint32_t version) {
672    fbb_.AddElement<uint32_t>(NanoappListEntry::VT_VERSION, version, 0);
673  }
674  void add_enabled(bool enabled) {
675    fbb_.AddElement<uint8_t>(NanoappListEntry::VT_ENABLED, static_cast<uint8_t>(enabled), 1);
676  }
677  void add_is_system(bool is_system) {
678    fbb_.AddElement<uint8_t>(NanoappListEntry::VT_IS_SYSTEM, static_cast<uint8_t>(is_system), 0);
679  }
680  NanoappListEntryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
681        : fbb_(_fbb) {
682    start_ = fbb_.StartTable();
683  }
684  NanoappListEntryBuilder &operator=(const NanoappListEntryBuilder &);
685  flatbuffers::Offset<NanoappListEntry> Finish() {
686    const auto end = fbb_.EndTable(start_, 4);
687    auto o = flatbuffers::Offset<NanoappListEntry>(end);
688    return o;
689  }
690};
691
692inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(
693    flatbuffers::FlatBufferBuilder &_fbb,
694    uint64_t app_id = 0,
695    uint32_t version = 0,
696    bool enabled = true,
697    bool is_system = false) {
698  NanoappListEntryBuilder builder_(_fbb);
699  builder_.add_app_id(app_id);
700  builder_.add_version(version);
701  builder_.add_is_system(is_system);
702  builder_.add_enabled(enabled);
703  return builder_.Finish();
704}
705
706flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
707
708struct NanoappListResponseT : public flatbuffers::NativeTable {
709  typedef NanoappListResponse TableType;
710  std::vector<std::unique_ptr<NanoappListEntryT>> nanoapps;
711  NanoappListResponseT() {
712  }
713};
714
715struct NanoappListResponse FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
716  typedef NanoappListResponseT NativeTableType;
717  enum {
718    VT_NANOAPPS = 4
719  };
720  const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps() const {
721    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS);
722  }
723  flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *mutable_nanoapps() {
724    return GetPointer<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>> *>(VT_NANOAPPS);
725  }
726  bool Verify(flatbuffers::Verifier &verifier) const {
727    return VerifyTableStart(verifier) &&
728           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_NANOAPPS) &&
729           verifier.Verify(nanoapps()) &&
730           verifier.VerifyVectorOfTables(nanoapps()) &&
731           verifier.EndTable();
732  }
733  NanoappListResponseT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
734  void UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
735  static flatbuffers::Offset<NanoappListResponse> Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
736};
737
738struct NanoappListResponseBuilder {
739  flatbuffers::FlatBufferBuilder &fbb_;
740  flatbuffers::uoffset_t start_;
741  void add_nanoapps(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps) {
742    fbb_.AddOffset(NanoappListResponse::VT_NANOAPPS, nanoapps);
743  }
744  NanoappListResponseBuilder(flatbuffers::FlatBufferBuilder &_fbb)
745        : fbb_(_fbb) {
746    start_ = fbb_.StartTable();
747  }
748  NanoappListResponseBuilder &operator=(const NanoappListResponseBuilder &);
749  flatbuffers::Offset<NanoappListResponse> Finish() {
750    const auto end = fbb_.EndTable(start_, 1);
751    auto o = flatbuffers::Offset<NanoappListResponse>(end);
752    fbb_.Required(o, NanoappListResponse::VT_NANOAPPS);
753    return o;
754  }
755};
756
757inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(
758    flatbuffers::FlatBufferBuilder &_fbb,
759    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<NanoappListEntry>>> nanoapps = 0) {
760  NanoappListResponseBuilder builder_(_fbb);
761  builder_.add_nanoapps(nanoapps);
762  return builder_.Finish();
763}
764
765inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponseDirect(
766    flatbuffers::FlatBufferBuilder &_fbb,
767    const std::vector<flatbuffers::Offset<NanoappListEntry>> *nanoapps = nullptr) {
768  return chre::fbs::CreateNanoappListResponse(
769      _fbb,
770      nanoapps ? _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(*nanoapps) : 0);
771}
772
773flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
774
775struct MessageContainerT : public flatbuffers::NativeTable {
776  typedef MessageContainer TableType;
777  ChreMessageUnion message;
778  MessageContainerT() {
779  }
780};
781
782/// The top-level container that encapsulates all possible messages. Note that
783/// per FlatBuffers requirements, we can't use a union as the top-level structure
784/// (root type), so we must wrap it in a table.
785struct MessageContainer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
786  typedef MessageContainerT NativeTableType;
787  enum {
788    VT_MESSAGE_TYPE = 4,
789    VT_MESSAGE = 6
790  };
791  ChreMessage message_type() const {
792    return static_cast<ChreMessage>(GetField<uint8_t>(VT_MESSAGE_TYPE, 0));
793  }
794  bool mutate_message_type(ChreMessage _message_type) {
795    return SetField(VT_MESSAGE_TYPE, static_cast<uint8_t>(_message_type));
796  }
797  const void *message() const {
798    return GetPointer<const void *>(VT_MESSAGE);
799  }
800  void *mutable_message() {
801    return GetPointer<void *>(VT_MESSAGE);
802  }
803  bool Verify(flatbuffers::Verifier &verifier) const {
804    return VerifyTableStart(verifier) &&
805           VerifyField<uint8_t>(verifier, VT_MESSAGE_TYPE) &&
806           VerifyFieldRequired<flatbuffers::uoffset_t>(verifier, VT_MESSAGE) &&
807           VerifyChreMessage(verifier, message(), message_type()) &&
808           verifier.EndTable();
809  }
810  MessageContainerT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
811  void UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
812  static flatbuffers::Offset<MessageContainer> Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
813};
814
815struct MessageContainerBuilder {
816  flatbuffers::FlatBufferBuilder &fbb_;
817  flatbuffers::uoffset_t start_;
818  void add_message_type(ChreMessage message_type) {
819    fbb_.AddElement<uint8_t>(MessageContainer::VT_MESSAGE_TYPE, static_cast<uint8_t>(message_type), 0);
820  }
821  void add_message(flatbuffers::Offset<void> message) {
822    fbb_.AddOffset(MessageContainer::VT_MESSAGE, message);
823  }
824  MessageContainerBuilder(flatbuffers::FlatBufferBuilder &_fbb)
825        : fbb_(_fbb) {
826    start_ = fbb_.StartTable();
827  }
828  MessageContainerBuilder &operator=(const MessageContainerBuilder &);
829  flatbuffers::Offset<MessageContainer> Finish() {
830    const auto end = fbb_.EndTable(start_, 2);
831    auto o = flatbuffers::Offset<MessageContainer>(end);
832    fbb_.Required(o, MessageContainer::VT_MESSAGE);
833    return o;
834  }
835};
836
837inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(
838    flatbuffers::FlatBufferBuilder &_fbb,
839    ChreMessage message_type = ChreMessage::NONE,
840    flatbuffers::Offset<void> message = 0) {
841  MessageContainerBuilder builder_(_fbb);
842  builder_.add_message(message);
843  builder_.add_message_type(message_type);
844  return builder_.Finish();
845}
846
847flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
848
849inline NanoappMessageT *NanoappMessage::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
850  auto _o = new NanoappMessageT();
851  UnPackTo(_o, _resolver);
852  return _o;
853}
854
855inline void NanoappMessage::UnPackTo(NanoappMessageT *_o, const flatbuffers::resolver_function_t *_resolver) const {
856  (void)_o;
857  (void)_resolver;
858  { auto _e = app_id(); _o->app_id = _e; };
859  { auto _e = message_type(); _o->message_type = _e; };
860  { auto _e = host_endpoint(); _o->host_endpoint = _e; };
861  { auto _e = message(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->message.push_back(_e->Get(_i)); } };
862}
863
864inline flatbuffers::Offset<NanoappMessage> NanoappMessage::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
865  return CreateNanoappMessage(_fbb, _o, _rehasher);
866}
867
868inline flatbuffers::Offset<NanoappMessage> CreateNanoappMessage(flatbuffers::FlatBufferBuilder &_fbb, const NanoappMessageT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
869  (void)_rehasher;
870  (void)_o;
871  auto _app_id = _o->app_id;
872  auto _message_type = _o->message_type;
873  auto _host_endpoint = _o->host_endpoint;
874  auto _message = _fbb.CreateVector(_o->message);
875  return chre::fbs::CreateNanoappMessage(
876      _fbb,
877      _app_id,
878      _message_type,
879      _host_endpoint,
880      _message);
881}
882
883inline HubInfoRequestT *HubInfoRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
884  auto _o = new HubInfoRequestT();
885  UnPackTo(_o, _resolver);
886  return _o;
887}
888
889inline void HubInfoRequest::UnPackTo(HubInfoRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
890  (void)_o;
891  (void)_resolver;
892}
893
894inline flatbuffers::Offset<HubInfoRequest> HubInfoRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
895  return CreateHubInfoRequest(_fbb, _o, _rehasher);
896}
897
898inline flatbuffers::Offset<HubInfoRequest> CreateHubInfoRequest(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
899  (void)_rehasher;
900  (void)_o;
901  return chre::fbs::CreateHubInfoRequest(
902      _fbb);
903}
904
905inline HubInfoResponseT *HubInfoResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
906  auto _o = new HubInfoResponseT();
907  UnPackTo(_o, _resolver);
908  return _o;
909}
910
911inline void HubInfoResponse::UnPackTo(HubInfoResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
912  (void)_o;
913  (void)_resolver;
914  { auto _e = name(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->name.push_back(_e->Get(_i)); } };
915  { auto _e = vendor(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->vendor.push_back(_e->Get(_i)); } };
916  { auto _e = toolchain(); if (_e) for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->toolchain.push_back(_e->Get(_i)); } };
917  { auto _e = platform_version(); _o->platform_version = _e; };
918  { auto _e = toolchain_version(); _o->toolchain_version = _e; };
919  { auto _e = peak_mips(); _o->peak_mips = _e; };
920  { auto _e = stopped_power(); _o->stopped_power = _e; };
921  { auto _e = sleep_power(); _o->sleep_power = _e; };
922  { auto _e = peak_power(); _o->peak_power = _e; };
923  { auto _e = max_msg_len(); _o->max_msg_len = _e; };
924  { auto _e = platform_id(); _o->platform_id = _e; };
925  { auto _e = chre_platform_version(); _o->chre_platform_version = _e; };
926}
927
928inline flatbuffers::Offset<HubInfoResponse> HubInfoResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
929  return CreateHubInfoResponse(_fbb, _o, _rehasher);
930}
931
932inline flatbuffers::Offset<HubInfoResponse> CreateHubInfoResponse(flatbuffers::FlatBufferBuilder &_fbb, const HubInfoResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
933  (void)_rehasher;
934  (void)_o;
935  auto _name = _o->name.size() ? _fbb.CreateVector(_o->name) : 0;
936  auto _vendor = _o->vendor.size() ? _fbb.CreateVector(_o->vendor) : 0;
937  auto _toolchain = _o->toolchain.size() ? _fbb.CreateVector(_o->toolchain) : 0;
938  auto _platform_version = _o->platform_version;
939  auto _toolchain_version = _o->toolchain_version;
940  auto _peak_mips = _o->peak_mips;
941  auto _stopped_power = _o->stopped_power;
942  auto _sleep_power = _o->sleep_power;
943  auto _peak_power = _o->peak_power;
944  auto _max_msg_len = _o->max_msg_len;
945  auto _platform_id = _o->platform_id;
946  auto _chre_platform_version = _o->chre_platform_version;
947  return chre::fbs::CreateHubInfoResponse(
948      _fbb,
949      _name,
950      _vendor,
951      _toolchain,
952      _platform_version,
953      _toolchain_version,
954      _peak_mips,
955      _stopped_power,
956      _sleep_power,
957      _peak_power,
958      _max_msg_len,
959      _platform_id,
960      _chre_platform_version);
961}
962
963inline NanoappListRequestT *NanoappListRequest::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
964  auto _o = new NanoappListRequestT();
965  UnPackTo(_o, _resolver);
966  return _o;
967}
968
969inline void NanoappListRequest::UnPackTo(NanoappListRequestT *_o, const flatbuffers::resolver_function_t *_resolver) const {
970  (void)_o;
971  (void)_resolver;
972}
973
974inline flatbuffers::Offset<NanoappListRequest> NanoappListRequest::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
975  return CreateNanoappListRequest(_fbb, _o, _rehasher);
976}
977
978inline flatbuffers::Offset<NanoappListRequest> CreateNanoappListRequest(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListRequestT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
979  (void)_rehasher;
980  (void)_o;
981  return chre::fbs::CreateNanoappListRequest(
982      _fbb);
983}
984
985inline NanoappListEntryT *NanoappListEntry::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
986  auto _o = new NanoappListEntryT();
987  UnPackTo(_o, _resolver);
988  return _o;
989}
990
991inline void NanoappListEntry::UnPackTo(NanoappListEntryT *_o, const flatbuffers::resolver_function_t *_resolver) const {
992  (void)_o;
993  (void)_resolver;
994  { auto _e = app_id(); _o->app_id = _e; };
995  { auto _e = version(); _o->version = _e; };
996  { auto _e = enabled(); _o->enabled = _e; };
997  { auto _e = is_system(); _o->is_system = _e; };
998}
999
1000inline flatbuffers::Offset<NanoappListEntry> NanoappListEntry::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1001  return CreateNanoappListEntry(_fbb, _o, _rehasher);
1002}
1003
1004inline flatbuffers::Offset<NanoappListEntry> CreateNanoappListEntry(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListEntryT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1005  (void)_rehasher;
1006  (void)_o;
1007  auto _app_id = _o->app_id;
1008  auto _version = _o->version;
1009  auto _enabled = _o->enabled;
1010  auto _is_system = _o->is_system;
1011  return chre::fbs::CreateNanoappListEntry(
1012      _fbb,
1013      _app_id,
1014      _version,
1015      _enabled,
1016      _is_system);
1017}
1018
1019inline NanoappListResponseT *NanoappListResponse::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1020  auto _o = new NanoappListResponseT();
1021  UnPackTo(_o, _resolver);
1022  return _o;
1023}
1024
1025inline void NanoappListResponse::UnPackTo(NanoappListResponseT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1026  (void)_o;
1027  (void)_resolver;
1028  { 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))); } };
1029}
1030
1031inline flatbuffers::Offset<NanoappListResponse> NanoappListResponse::Pack(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1032  return CreateNanoappListResponse(_fbb, _o, _rehasher);
1033}
1034
1035inline flatbuffers::Offset<NanoappListResponse> CreateNanoappListResponse(flatbuffers::FlatBufferBuilder &_fbb, const NanoappListResponseT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1036  (void)_rehasher;
1037  (void)_o;
1038  auto _nanoapps = _fbb.CreateVector<flatbuffers::Offset<NanoappListEntry>>(_o->nanoapps.size(), [&](size_t i) { return CreateNanoappListEntry(_fbb, _o->nanoapps[i].get(), _rehasher); });
1039  return chre::fbs::CreateNanoappListResponse(
1040      _fbb,
1041      _nanoapps);
1042}
1043
1044inline MessageContainerT *MessageContainer::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
1045  auto _o = new MessageContainerT();
1046  UnPackTo(_o, _resolver);
1047  return _o;
1048}
1049
1050inline void MessageContainer::UnPackTo(MessageContainerT *_o, const flatbuffers::resolver_function_t *_resolver) const {
1051  (void)_o;
1052  (void)_resolver;
1053  { auto _e = message_type(); _o->message.type = _e; };
1054  { auto _e = message(); if (_e) _o->message.table = ChreMessageUnion::UnPack(_e, message_type(),_resolver); };
1055}
1056
1057inline flatbuffers::Offset<MessageContainer> MessageContainer::Pack(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
1058  return CreateMessageContainer(_fbb, _o, _rehasher);
1059}
1060
1061inline flatbuffers::Offset<MessageContainer> CreateMessageContainer(flatbuffers::FlatBufferBuilder &_fbb, const MessageContainerT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
1062  (void)_rehasher;
1063  (void)_o;
1064  auto _message_type = _o->message.type;
1065  auto _message = _o->message.Pack(_fbb);
1066  return chre::fbs::CreateMessageContainer(
1067      _fbb,
1068      _message_type,
1069      _message);
1070}
1071
1072inline bool VerifyChreMessage(flatbuffers::Verifier &verifier, const void *obj, ChreMessage type) {
1073  switch (type) {
1074    case ChreMessage::NONE: {
1075      return true;
1076    }
1077    case ChreMessage::NanoappMessage: {
1078      auto ptr = reinterpret_cast<const NanoappMessage *>(obj);
1079      return verifier.VerifyTable(ptr);
1080    }
1081    case ChreMessage::HubInfoRequest: {
1082      auto ptr = reinterpret_cast<const HubInfoRequest *>(obj);
1083      return verifier.VerifyTable(ptr);
1084    }
1085    case ChreMessage::HubInfoResponse: {
1086      auto ptr = reinterpret_cast<const HubInfoResponse *>(obj);
1087      return verifier.VerifyTable(ptr);
1088    }
1089    case ChreMessage::NanoappListRequest: {
1090      auto ptr = reinterpret_cast<const NanoappListRequest *>(obj);
1091      return verifier.VerifyTable(ptr);
1092    }
1093    case ChreMessage::NanoappListResponse: {
1094      auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
1095      return verifier.VerifyTable(ptr);
1096    }
1097    default: return false;
1098  }
1099}
1100
1101inline bool VerifyChreMessageVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
1102  if (values->size() != types->size()) return false;
1103  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
1104    if (!VerifyChreMessage(
1105        verifier,  values->Get(i), types->GetEnum<ChreMessage>(i))) {
1106      return false;
1107    }
1108  }
1109  return true;
1110}
1111
1112inline flatbuffers::NativeTable *ChreMessageUnion::UnPack(const void *obj, ChreMessage type, const flatbuffers::resolver_function_t *resolver) {
1113  switch (type) {
1114    case ChreMessage::NanoappMessage: {
1115      auto ptr = reinterpret_cast<const NanoappMessage *>(obj);
1116      return ptr->UnPack(resolver);
1117    }
1118    case ChreMessage::HubInfoRequest: {
1119      auto ptr = reinterpret_cast<const HubInfoRequest *>(obj);
1120      return ptr->UnPack(resolver);
1121    }
1122    case ChreMessage::HubInfoResponse: {
1123      auto ptr = reinterpret_cast<const HubInfoResponse *>(obj);
1124      return ptr->UnPack(resolver);
1125    }
1126    case ChreMessage::NanoappListRequest: {
1127      auto ptr = reinterpret_cast<const NanoappListRequest *>(obj);
1128      return ptr->UnPack(resolver);
1129    }
1130    case ChreMessage::NanoappListResponse: {
1131      auto ptr = reinterpret_cast<const NanoappListResponse *>(obj);
1132      return ptr->UnPack(resolver);
1133    }
1134    default: return nullptr;
1135  }
1136}
1137
1138inline flatbuffers::Offset<void> ChreMessageUnion::Pack(flatbuffers::FlatBufferBuilder &_fbb, const flatbuffers::rehasher_function_t *_rehasher) const {
1139  switch (type) {
1140    case ChreMessage::NanoappMessage: {
1141      auto ptr = reinterpret_cast<const NanoappMessageT *>(table);
1142      return CreateNanoappMessage(_fbb, ptr, _rehasher).Union();
1143    }
1144    case ChreMessage::HubInfoRequest: {
1145      auto ptr = reinterpret_cast<const HubInfoRequestT *>(table);
1146      return CreateHubInfoRequest(_fbb, ptr, _rehasher).Union();
1147    }
1148    case ChreMessage::HubInfoResponse: {
1149      auto ptr = reinterpret_cast<const HubInfoResponseT *>(table);
1150      return CreateHubInfoResponse(_fbb, ptr, _rehasher).Union();
1151    }
1152    case ChreMessage::NanoappListRequest: {
1153      auto ptr = reinterpret_cast<const NanoappListRequestT *>(table);
1154      return CreateNanoappListRequest(_fbb, ptr, _rehasher).Union();
1155    }
1156    case ChreMessage::NanoappListResponse: {
1157      auto ptr = reinterpret_cast<const NanoappListResponseT *>(table);
1158      return CreateNanoappListResponse(_fbb, ptr, _rehasher).Union();
1159    }
1160    default: return 0;
1161  }
1162}
1163
1164inline void ChreMessageUnion::Reset() {
1165  switch (type) {
1166    case ChreMessage::NanoappMessage: {
1167      auto ptr = reinterpret_cast<NanoappMessageT *>(table);
1168      delete ptr;
1169      break;
1170    }
1171    case ChreMessage::HubInfoRequest: {
1172      auto ptr = reinterpret_cast<HubInfoRequestT *>(table);
1173      delete ptr;
1174      break;
1175    }
1176    case ChreMessage::HubInfoResponse: {
1177      auto ptr = reinterpret_cast<HubInfoResponseT *>(table);
1178      delete ptr;
1179      break;
1180    }
1181    case ChreMessage::NanoappListRequest: {
1182      auto ptr = reinterpret_cast<NanoappListRequestT *>(table);
1183      delete ptr;
1184      break;
1185    }
1186    case ChreMessage::NanoappListResponse: {
1187      auto ptr = reinterpret_cast<NanoappListResponseT *>(table);
1188      delete ptr;
1189      break;
1190    }
1191    default: break;
1192  }
1193  table = nullptr;
1194  type = ChreMessage::NONE;
1195}
1196
1197inline const chre::fbs::MessageContainer *GetMessageContainer(const void *buf) {
1198  return flatbuffers::GetRoot<chre::fbs::MessageContainer>(buf);
1199}
1200
1201inline MessageContainer *GetMutableMessageContainer(void *buf) {
1202  return flatbuffers::GetMutableRoot<MessageContainer>(buf);
1203}
1204
1205inline bool VerifyMessageContainerBuffer(
1206    flatbuffers::Verifier &verifier) {
1207  return verifier.VerifyBuffer<chre::fbs::MessageContainer>(nullptr);
1208}
1209
1210inline void FinishMessageContainerBuffer(
1211    flatbuffers::FlatBufferBuilder &fbb,
1212    flatbuffers::Offset<chre::fbs::MessageContainer> root) {
1213  fbb.Finish(root);
1214}
1215
1216inline std::unique_ptr<MessageContainerT> UnPackMessageContainer(
1217    const void *buf,
1218    const flatbuffers::resolver_function_t *res = nullptr) {
1219  return std::unique_ptr<MessageContainerT>(GetMessageContainer(buf)->UnPack(res));
1220}
1221
1222}  // namespace fbs
1223}  // namespace chre
1224
1225#endif  // FLATBUFFERS_GENERATED_HOSTMESSAGES_CHRE_FBS_H_
1226