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