| // WARNING: This file is machine generated by fidlgen. |
| |
| // fidl_experiment = output_index_json |
| |
| #pragma once |
| |
| #include "lib/fidl/cpp/internal/header.h" |
| |
| namespace test { |
| namespace protocollayoutssamelibrary { |
| |
| |
| // |
| // Domain objects declarations |
| // |
| |
| |
| class TablePayload; |
| |
| |
| class UnionPayload; |
| |
| |
| class ComposedProtocolOneWayAnonComposedRequest; |
| |
| |
| class ComposedProtocolTwoWayAnonComposedRequest; |
| |
| |
| class ComposedProtocolTwoWayAnonComposedResponse; |
| |
| |
| class ComposedProtocolTwoWayAnonComposedWithErrorRequest; |
| |
| |
| class ComposedProtocol_TwoWayAnonComposedWithError_Response; |
| |
| |
| class ComposedProtocol_TwoWayAnonComposedWithError_Result; |
| |
| |
| class ComposedProtocolOnAnonComposedRequest; |
| |
| |
| class ComposedProtocol_TwoWayNamedComposedWithError_Result; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| class ComposedProtocol; |
| using ComposedProtocolHandle = ::fidl::InterfaceHandle<ComposedProtocol>; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| class MainProtocol_TwoWayLocalWithError_Result; |
| |
| |
| class MainProtocolOneWayAnonRequest; |
| |
| |
| class MainProtocolTwoWayAnonRequest; |
| |
| |
| class MainProtocolTwoWayAnonResponse; |
| |
| |
| class MainProtocolTwoWayAnonWithErrorRequest; |
| |
| |
| class MainProtocol_TwoWayAnonWithError_Response; |
| |
| |
| class MainProtocol_TwoWayAnonWithError_Result; |
| |
| |
| class MainProtocolOnAnonRequest; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| class MainProtocol; |
| using MainProtocolHandle = ::fidl::InterfaceHandle<MainProtocol>; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| class TablePayload final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const uint16_t& a() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return a_value_.value; |
| } |
| bool has_a() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| uint16_t* mutable_a() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&a_value_.value); |
| } |
| return &a_value_.value; |
| } |
| TablePayload& set_a(uint16_t _value); |
| void clear_a() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&a_value_.value); |
| } |
| |
| TablePayload(); |
| TablePayload(TablePayload&& other); |
| ~TablePayload(); |
| TablePayload& operator=(TablePayload&& other); |
| |
| static inline ::std::unique_ptr<TablePayload> New() { return ::std::make_unique<TablePayload>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, TablePayload* _value, size_t _offset); |
| zx_status_t Clone(TablePayload* _result) const; |
| private: |
| template <class T, class... Args> |
| void Construct(T* p, Args&&... args) { |
| new (p) T(std::forward<Args>(args)...); |
| } |
| |
| template <class T> |
| void Destruct(T* p) { |
| p->~T(); |
| } |
| |
| size_t MaxOrdinal() const { |
| return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1}; |
| } |
| |
| static bool IsOrdinalKnown(uint64_t ordinal) { |
| switch (ordinal) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| ::fidl::internal::BitSet<1> field_presence_; |
| union ValueUnion_a { |
| ValueUnion_a() {} |
| ~ValueUnion_a() {} |
| |
| uint16_t value; |
| }; |
| ValueUnion_a a_value_; |
| }; |
| |
| using TablePayloadPtr = ::std::unique_ptr<TablePayload>; |
| |
| |
| |
| class UnionPayload final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnionPayload(); |
| ~UnionPayload(); |
| |
| UnionPayload(UnionPayload&&); |
| UnionPayload& operator=(UnionPayload&&); |
| |
| |
| static UnionPayload WithB(bool&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kB = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnionPayload> New() { return ::std::make_unique<UnionPayload>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnionPayload* value, size_t offset); |
| zx_status_t Clone(UnionPayload* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::UnionPayload::Tag::kB; } |
| |
| bool& b() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::UnionPayload::Tag::kB); |
| return b_; |
| } |
| |
| const bool& b() const { |
| ZX_ASSERT(is_b()); |
| return b_; |
| } |
| UnionPayload& set_b(bool value); |
| |
| ::test::protocollayoutssamelibrary::UnionPayload::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::UnionPayload::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::UnionPayload>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::UnionPayload::Tag::Invalid); |
| union { |
| bool b_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::UnionPayload& value, |
| ::test::protocollayoutssamelibrary::UnionPayload* result) { |
| return value.Clone(result); |
| } |
| |
| using UnionPayloadPtr = ::std::unique_ptr<UnionPayload>; |
| |
| |
| |
| class ComposedProtocolOneWayAnonComposedRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const uint16_t& a() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return a_value_.value; |
| } |
| bool has_a() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| uint16_t* mutable_a() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&a_value_.value); |
| } |
| return &a_value_.value; |
| } |
| ComposedProtocolOneWayAnonComposedRequest& set_a(uint16_t _value); |
| void clear_a() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&a_value_.value); |
| } |
| |
| ComposedProtocolOneWayAnonComposedRequest(); |
| ComposedProtocolOneWayAnonComposedRequest(ComposedProtocolOneWayAnonComposedRequest&& other); |
| ~ComposedProtocolOneWayAnonComposedRequest(); |
| ComposedProtocolOneWayAnonComposedRequest& operator=(ComposedProtocolOneWayAnonComposedRequest&& other); |
| |
| static inline ::std::unique_ptr<ComposedProtocolOneWayAnonComposedRequest> New() { return ::std::make_unique<ComposedProtocolOneWayAnonComposedRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocolOneWayAnonComposedRequest* _value, size_t _offset); |
| zx_status_t Clone(ComposedProtocolOneWayAnonComposedRequest* _result) const; |
| private: |
| template <class T, class... Args> |
| void Construct(T* p, Args&&... args) { |
| new (p) T(std::forward<Args>(args)...); |
| } |
| |
| template <class T> |
| void Destruct(T* p) { |
| p->~T(); |
| } |
| |
| size_t MaxOrdinal() const { |
| return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1}; |
| } |
| |
| static bool IsOrdinalKnown(uint64_t ordinal) { |
| switch (ordinal) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| ::fidl::internal::BitSet<1> field_presence_; |
| union ValueUnion_a { |
| ValueUnion_a() {} |
| ~ValueUnion_a() {} |
| |
| uint16_t value; |
| }; |
| ValueUnion_a a_value_; |
| }; |
| |
| using ComposedProtocolOneWayAnonComposedRequestPtr = ::std::unique_ptr<ComposedProtocolOneWayAnonComposedRequest>; |
| |
| |
| |
| class ComposedProtocolTwoWayAnonComposedRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ComposedProtocolTwoWayAnonComposedRequest(); |
| ~ComposedProtocolTwoWayAnonComposedRequest(); |
| |
| ComposedProtocolTwoWayAnonComposedRequest(ComposedProtocolTwoWayAnonComposedRequest&&); |
| ComposedProtocolTwoWayAnonComposedRequest& operator=(ComposedProtocolTwoWayAnonComposedRequest&&); |
| |
| |
| static ComposedProtocolTwoWayAnonComposedRequest WithB(bool&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kB = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedRequest> New() { return ::std::make_unique<ComposedProtocolTwoWayAnonComposedRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocolTwoWayAnonComposedRequest* value, size_t offset); |
| zx_status_t Clone(ComposedProtocolTwoWayAnonComposedRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::kB; } |
| |
| bool& b() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::kB); |
| return b_; |
| } |
| |
| const bool& b() const { |
| ZX_ASSERT(is_b()); |
| return b_; |
| } |
| ComposedProtocolTwoWayAnonComposedRequest& set_b(bool value); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::Invalid); |
| union { |
| bool b_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using ComposedProtocolTwoWayAnonComposedRequestPtr = ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedRequest>; |
| |
| |
| |
| class ComposedProtocolTwoWayAnonComposedResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const uint16_t& a() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return a_value_.value; |
| } |
| bool has_a() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| uint16_t* mutable_a() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&a_value_.value); |
| } |
| return &a_value_.value; |
| } |
| ComposedProtocolTwoWayAnonComposedResponse& set_a(uint16_t _value); |
| void clear_a() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&a_value_.value); |
| } |
| |
| ComposedProtocolTwoWayAnonComposedResponse(); |
| ComposedProtocolTwoWayAnonComposedResponse(ComposedProtocolTwoWayAnonComposedResponse&& other); |
| ~ComposedProtocolTwoWayAnonComposedResponse(); |
| ComposedProtocolTwoWayAnonComposedResponse& operator=(ComposedProtocolTwoWayAnonComposedResponse&& other); |
| |
| static inline ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedResponse> New() { return ::std::make_unique<ComposedProtocolTwoWayAnonComposedResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocolTwoWayAnonComposedResponse* _value, size_t _offset); |
| zx_status_t Clone(ComposedProtocolTwoWayAnonComposedResponse* _result) const; |
| private: |
| template <class T, class... Args> |
| void Construct(T* p, Args&&... args) { |
| new (p) T(std::forward<Args>(args)...); |
| } |
| |
| template <class T> |
| void Destruct(T* p) { |
| p->~T(); |
| } |
| |
| size_t MaxOrdinal() const { |
| return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1}; |
| } |
| |
| static bool IsOrdinalKnown(uint64_t ordinal) { |
| switch (ordinal) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| ::fidl::internal::BitSet<1> field_presence_; |
| union ValueUnion_a { |
| ValueUnion_a() {} |
| ~ValueUnion_a() {} |
| |
| uint16_t value; |
| }; |
| ValueUnion_a a_value_; |
| }; |
| |
| using ComposedProtocolTwoWayAnonComposedResponsePtr = ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedResponse>; |
| |
| |
| |
| class ComposedProtocolTwoWayAnonComposedWithErrorRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const uint16_t& a() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return a_value_.value; |
| } |
| bool has_a() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| uint16_t* mutable_a() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&a_value_.value); |
| } |
| return &a_value_.value; |
| } |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest& set_a(uint16_t _value); |
| void clear_a() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&a_value_.value); |
| } |
| |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest(); |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest(ComposedProtocolTwoWayAnonComposedWithErrorRequest&& other); |
| ~ComposedProtocolTwoWayAnonComposedWithErrorRequest(); |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest& operator=(ComposedProtocolTwoWayAnonComposedWithErrorRequest&& other); |
| |
| static inline ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedWithErrorRequest> New() { return ::std::make_unique<ComposedProtocolTwoWayAnonComposedWithErrorRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocolTwoWayAnonComposedWithErrorRequest* _value, size_t _offset); |
| zx_status_t Clone(ComposedProtocolTwoWayAnonComposedWithErrorRequest* _result) const; |
| private: |
| template <class T, class... Args> |
| void Construct(T* p, Args&&... args) { |
| new (p) T(std::forward<Args>(args)...); |
| } |
| |
| template <class T> |
| void Destruct(T* p) { |
| p->~T(); |
| } |
| |
| size_t MaxOrdinal() const { |
| return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1}; |
| } |
| |
| static bool IsOrdinalKnown(uint64_t ordinal) { |
| switch (ordinal) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| ::fidl::internal::BitSet<1> field_presence_; |
| union ValueUnion_a { |
| ValueUnion_a() {} |
| ~ValueUnion_a() {} |
| |
| uint16_t value; |
| }; |
| ValueUnion_a a_value_; |
| }; |
| |
| using ComposedProtocolTwoWayAnonComposedWithErrorRequestPtr = ::std::unique_ptr<ComposedProtocolTwoWayAnonComposedWithErrorRequest>; |
| |
| |
| |
| class ComposedProtocol_TwoWayAnonComposedWithError_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ComposedProtocol_TwoWayAnonComposedWithError_Response(); |
| ~ComposedProtocol_TwoWayAnonComposedWithError_Response(); |
| |
| ComposedProtocol_TwoWayAnonComposedWithError_Response(ComposedProtocol_TwoWayAnonComposedWithError_Response&&); |
| ComposedProtocol_TwoWayAnonComposedWithError_Response& operator=(ComposedProtocol_TwoWayAnonComposedWithError_Response&&); |
| |
| |
| static ComposedProtocol_TwoWayAnonComposedWithError_Response WithB(bool&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kB = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ComposedProtocol_TwoWayAnonComposedWithError_Response> New() { return ::std::make_unique<ComposedProtocol_TwoWayAnonComposedWithError_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocol_TwoWayAnonComposedWithError_Response* value, size_t offset); |
| zx_status_t Clone(ComposedProtocol_TwoWayAnonComposedWithError_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::kB; } |
| |
| bool& b() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::kB); |
| return b_; |
| } |
| |
| const bool& b() const { |
| ZX_ASSERT(is_b()); |
| return b_; |
| } |
| ComposedProtocol_TwoWayAnonComposedWithError_Response& set_b(bool value); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::Invalid); |
| union { |
| bool b_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using ComposedProtocol_TwoWayAnonComposedWithError_ResponsePtr = ::std::unique_ptr<ComposedProtocol_TwoWayAnonComposedWithError_Response>; |
| |
| |
| |
| class ComposedProtocol_TwoWayAnonComposedWithError_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ComposedProtocol_TwoWayAnonComposedWithError_Result(); |
| ~ComposedProtocol_TwoWayAnonComposedWithError_Result(); |
| |
| ComposedProtocol_TwoWayAnonComposedWithError_Result(ComposedProtocol_TwoWayAnonComposedWithError_Result&&); |
| ComposedProtocol_TwoWayAnonComposedWithError_Result& operator=(ComposedProtocol_TwoWayAnonComposedWithError_Result&&); |
| |
| |
| static ComposedProtocol_TwoWayAnonComposedWithError_Result WithResponse(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response&&); |
| static ComposedProtocol_TwoWayAnonComposedWithError_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ComposedProtocol_TwoWayAnonComposedWithError_Result> New() { return ::std::make_unique<ComposedProtocol_TwoWayAnonComposedWithError_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocol_TwoWayAnonComposedWithError_Result* value, size_t offset); |
| zx_status_t Clone(ComposedProtocol_TwoWayAnonComposedWithError_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kResponse; } |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& response() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| ComposedProtocol_TwoWayAnonComposedWithError_Result& set_response(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response value); |
| |
| bool is_err() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| ComposedProtocol_TwoWayAnonComposedWithError_Result& set_err(uint32_t value); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result>; |
| ComposedProtocol_TwoWayAnonComposedWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>&& result) { |
| set_response(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response{std::move(result.value)}); |
| } |
| ComposedProtocol_TwoWayAnonComposedWithError_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| ComposedProtocol_TwoWayAnonComposedWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::Invalid); |
| union { |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using ComposedProtocol_TwoWayAnonComposedWithError_ResultPtr = ::std::unique_ptr<ComposedProtocol_TwoWayAnonComposedWithError_Result>; |
| |
| |
| |
| class ComposedProtocolOnAnonComposedRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ComposedProtocolOnAnonComposedRequest(); |
| ~ComposedProtocolOnAnonComposedRequest(); |
| |
| ComposedProtocolOnAnonComposedRequest(ComposedProtocolOnAnonComposedRequest&&); |
| ComposedProtocolOnAnonComposedRequest& operator=(ComposedProtocolOnAnonComposedRequest&&); |
| |
| |
| static ComposedProtocolOnAnonComposedRequest WithB(bool&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kB = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ComposedProtocolOnAnonComposedRequest> New() { return ::std::make_unique<ComposedProtocolOnAnonComposedRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocolOnAnonComposedRequest* value, size_t offset); |
| zx_status_t Clone(ComposedProtocolOnAnonComposedRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::kB; } |
| |
| bool& b() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::kB); |
| return b_; |
| } |
| |
| const bool& b() const { |
| ZX_ASSERT(is_b()); |
| return b_; |
| } |
| ComposedProtocolOnAnonComposedRequest& set_b(bool value); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::Invalid); |
| union { |
| bool b_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using ComposedProtocolOnAnonComposedRequestPtr = ::std::unique_ptr<ComposedProtocolOnAnonComposedRequest>; |
| |
| |
| |
| class ComposedProtocol_TwoWayNamedComposedWithError_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ComposedProtocol_TwoWayNamedComposedWithError_Result(); |
| ~ComposedProtocol_TwoWayNamedComposedWithError_Result(); |
| |
| ComposedProtocol_TwoWayNamedComposedWithError_Result(ComposedProtocol_TwoWayNamedComposedWithError_Result&&); |
| ComposedProtocol_TwoWayNamedComposedWithError_Result& operator=(ComposedProtocol_TwoWayNamedComposedWithError_Result&&); |
| |
| |
| static ComposedProtocol_TwoWayNamedComposedWithError_Result WithResponse(::test::protocollayoutssamelibrary::UnionPayload&&); |
| static ComposedProtocol_TwoWayNamedComposedWithError_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ComposedProtocol_TwoWayNamedComposedWithError_Result> New() { return ::std::make_unique<ComposedProtocol_TwoWayNamedComposedWithError_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ComposedProtocol_TwoWayNamedComposedWithError_Result* value, size_t offset); |
| zx_status_t Clone(ComposedProtocol_TwoWayNamedComposedWithError_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kResponse; } |
| |
| ::test::protocollayoutssamelibrary::UnionPayload& response() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::protocollayoutssamelibrary::UnionPayload& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| ComposedProtocol_TwoWayNamedComposedWithError_Result& set_response(::test::protocollayoutssamelibrary::UnionPayload value); |
| |
| bool is_err() const { return tag_ == ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| ComposedProtocol_TwoWayNamedComposedWithError_Result& set_err(uint32_t value); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result>; |
| ComposedProtocol_TwoWayNamedComposedWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::UnionPayload>&& result) { |
| set_response(::test::protocollayoutssamelibrary::UnionPayload{std::move(result.value)}); |
| } |
| ComposedProtocol_TwoWayNamedComposedWithError_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| ComposedProtocol_TwoWayNamedComposedWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::protocollayoutssamelibrary::UnionPayload{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::protocollayoutssamelibrary::UnionPayload> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::Invalid); |
| union { |
| ::test::protocollayoutssamelibrary::UnionPayload response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using ComposedProtocol_TwoWayNamedComposedWithError_ResultPtr = ::std::unique_ptr<ComposedProtocol_TwoWayNamedComposedWithError_Result>; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolOneWayAnonComposedRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolTwoWayAnonComposedRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolTwoWayAnonComposedWithErrorRequestTable; |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_TablePayloadTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_UnionPayloadTable; |
| |
| |
| |
| } // namespace _internal |
| |
| class ComposedProtocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage OneWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest* ComposedProtocolOneWayAnonComposedRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolOneWayAnonComposedRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest* ComposedProtocolTwoWayAnonComposedRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest* ComposedProtocolTwoWayAnonComposedWithErrorRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedWithErrorRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OneWayNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::UnionPayload* UnionPayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnionPayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolTwoWayAnonComposedResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocol_TwoWayAnonComposedWithError_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocolOnAnonComposedRequestTable; |
| |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_ComposedProtocol_TwoWayNamedComposedWithError_ResultTable; |
| |
| |
| } // namespace _internal |
| |
| class ComposedProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* ComposedProtocolTwoWayAnonComposedResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* ComposedProtocol_TwoWayAnonComposedWithError_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocol_TwoWayAnonComposedWithError_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest* ComposedProtocolOnAnonComposedRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolOnAnonComposedRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* ComposedProtocol_TwoWayNamedComposedWithError_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocol_TwoWayNamedComposedWithError_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::UnionPayload* UnionPayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnionPayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| class MainProtocol_TwoWayLocalWithError_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| MainProtocol_TwoWayLocalWithError_Result(); |
| ~MainProtocol_TwoWayLocalWithError_Result(); |
| |
| MainProtocol_TwoWayLocalWithError_Result(MainProtocol_TwoWayLocalWithError_Result&&); |
| MainProtocol_TwoWayLocalWithError_Result& operator=(MainProtocol_TwoWayLocalWithError_Result&&); |
| |
| |
| static MainProtocol_TwoWayLocalWithError_Result WithResponse(::test::protocollayoutssamelibrary::UnionPayload&&); |
| static MainProtocol_TwoWayLocalWithError_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<MainProtocol_TwoWayLocalWithError_Result> New() { return ::std::make_unique<MainProtocol_TwoWayLocalWithError_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocol_TwoWayLocalWithError_Result* value, size_t offset); |
| zx_status_t Clone(MainProtocol_TwoWayLocalWithError_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse; } |
| |
| ::test::protocollayoutssamelibrary::UnionPayload& response() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::protocollayoutssamelibrary::UnionPayload& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| MainProtocol_TwoWayLocalWithError_Result& set_response(::test::protocollayoutssamelibrary::UnionPayload value); |
| |
| bool is_err() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| MainProtocol_TwoWayLocalWithError_Result& set_err(uint32_t value); |
| |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result>; |
| MainProtocol_TwoWayLocalWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::UnionPayload>&& result) { |
| set_response(::test::protocollayoutssamelibrary::UnionPayload{std::move(result.value)}); |
| } |
| MainProtocol_TwoWayLocalWithError_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| MainProtocol_TwoWayLocalWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::protocollayoutssamelibrary::UnionPayload{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::protocollayoutssamelibrary::UnionPayload, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::protocollayoutssamelibrary::UnionPayload> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::Invalid); |
| union { |
| ::test::protocollayoutssamelibrary::UnionPayload response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result& value, |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using MainProtocol_TwoWayLocalWithError_ResultPtr = ::std::unique_ptr<MainProtocol_TwoWayLocalWithError_Result>; |
| |
| |
| |
| class MainProtocolOneWayAnonRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const uint16_t& a() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return a_value_.value; |
| } |
| bool has_a() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| uint16_t* mutable_a() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&a_value_.value); |
| } |
| return &a_value_.value; |
| } |
| MainProtocolOneWayAnonRequest& set_a(uint16_t _value); |
| void clear_a() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&a_value_.value); |
| } |
| |
| MainProtocolOneWayAnonRequest(); |
| MainProtocolOneWayAnonRequest(MainProtocolOneWayAnonRequest&& other); |
| ~MainProtocolOneWayAnonRequest(); |
| MainProtocolOneWayAnonRequest& operator=(MainProtocolOneWayAnonRequest&& other); |
| |
| static inline ::std::unique_ptr<MainProtocolOneWayAnonRequest> New() { return ::std::make_unique<MainProtocolOneWayAnonRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocolOneWayAnonRequest* _value, size_t _offset); |
| zx_status_t Clone(MainProtocolOneWayAnonRequest* _result) const; |
| private: |
| template <class T, class... Args> |
| void Construct(T* p, Args&&... args) { |
| new (p) T(std::forward<Args>(args)...); |
| } |
| |
| template <class T> |
| void Destruct(T* p) { |
| p->~T(); |
| } |
| |
| size_t MaxOrdinal() const { |
| return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1}; |
| } |
| |
| static bool IsOrdinalKnown(uint64_t ordinal) { |
| switch (ordinal) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| ::fidl::internal::BitSet<1> field_presence_; |
| union ValueUnion_a { |
| ValueUnion_a() {} |
| ~ValueUnion_a() {} |
| |
| uint16_t value; |
| }; |
| ValueUnion_a a_value_; |
| }; |
| |
| using MainProtocolOneWayAnonRequestPtr = ::std::unique_ptr<MainProtocolOneWayAnonRequest>; |
| |
| |
| |
| class MainProtocolTwoWayAnonRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| MainProtocolTwoWayAnonRequest(); |
| ~MainProtocolTwoWayAnonRequest(); |
| |
| MainProtocolTwoWayAnonRequest(MainProtocolTwoWayAnonRequest&&); |
| MainProtocolTwoWayAnonRequest& operator=(MainProtocolTwoWayAnonRequest&&); |
| |
| |
| static MainProtocolTwoWayAnonRequest WithB(bool&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kB = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<MainProtocolTwoWayAnonRequest> New() { return ::std::make_unique<MainProtocolTwoWayAnonRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocolTwoWayAnonRequest* value, size_t offset); |
| zx_status_t Clone(MainProtocolTwoWayAnonRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kB; } |
| |
| bool& b() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kB); |
| return b_; |
| } |
| |
| const bool& b() const { |
| ZX_ASSERT(is_b()); |
| return b_; |
| } |
| MainProtocolTwoWayAnonRequest& set_b(bool value); |
| MainProtocolTwoWayAnonRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::Invalid: |
| case ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kB: |
| return ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag(tag_); |
| default: |
| return ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::Invalid); |
| union { |
| bool b_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest& value, |
| ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using MainProtocolTwoWayAnonRequestPtr = ::std::unique_ptr<MainProtocolTwoWayAnonRequest>; |
| |
| |
| |
| class MainProtocolTwoWayAnonResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const uint16_t& a() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return a_value_.value; |
| } |
| bool has_a() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| uint16_t* mutable_a() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&a_value_.value); |
| } |
| return &a_value_.value; |
| } |
| MainProtocolTwoWayAnonResponse& set_a(uint16_t _value); |
| void clear_a() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&a_value_.value); |
| } |
| |
| MainProtocolTwoWayAnonResponse(); |
| MainProtocolTwoWayAnonResponse(MainProtocolTwoWayAnonResponse&& other); |
| ~MainProtocolTwoWayAnonResponse(); |
| MainProtocolTwoWayAnonResponse& operator=(MainProtocolTwoWayAnonResponse&& other); |
| |
| static inline ::std::unique_ptr<MainProtocolTwoWayAnonResponse> New() { return ::std::make_unique<MainProtocolTwoWayAnonResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocolTwoWayAnonResponse* _value, size_t _offset); |
| zx_status_t Clone(MainProtocolTwoWayAnonResponse* _result) const; |
| private: |
| template <class T, class... Args> |
| void Construct(T* p, Args&&... args) { |
| new (p) T(std::forward<Args>(args)...); |
| } |
| |
| template <class T> |
| void Destruct(T* p) { |
| p->~T(); |
| } |
| |
| size_t MaxOrdinal() const { |
| return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1}; |
| } |
| |
| static bool IsOrdinalKnown(uint64_t ordinal) { |
| switch (ordinal) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| ::fidl::internal::BitSet<1> field_presence_; |
| union ValueUnion_a { |
| ValueUnion_a() {} |
| ~ValueUnion_a() {} |
| |
| uint16_t value; |
| }; |
| ValueUnion_a a_value_; |
| }; |
| |
| using MainProtocolTwoWayAnonResponsePtr = ::std::unique_ptr<MainProtocolTwoWayAnonResponse>; |
| |
| |
| |
| class MainProtocolTwoWayAnonWithErrorRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const uint16_t& a() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return a_value_.value; |
| } |
| bool has_a() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| uint16_t* mutable_a() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&a_value_.value); |
| } |
| return &a_value_.value; |
| } |
| MainProtocolTwoWayAnonWithErrorRequest& set_a(uint16_t _value); |
| void clear_a() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&a_value_.value); |
| } |
| |
| MainProtocolTwoWayAnonWithErrorRequest(); |
| MainProtocolTwoWayAnonWithErrorRequest(MainProtocolTwoWayAnonWithErrorRequest&& other); |
| ~MainProtocolTwoWayAnonWithErrorRequest(); |
| MainProtocolTwoWayAnonWithErrorRequest& operator=(MainProtocolTwoWayAnonWithErrorRequest&& other); |
| |
| static inline ::std::unique_ptr<MainProtocolTwoWayAnonWithErrorRequest> New() { return ::std::make_unique<MainProtocolTwoWayAnonWithErrorRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocolTwoWayAnonWithErrorRequest* _value, size_t _offset); |
| zx_status_t Clone(MainProtocolTwoWayAnonWithErrorRequest* _result) const; |
| private: |
| template <class T, class... Args> |
| void Construct(T* p, Args&&... args) { |
| new (p) T(std::forward<Args>(args)...); |
| } |
| |
| template <class T> |
| void Destruct(T* p) { |
| p->~T(); |
| } |
| |
| size_t MaxOrdinal() const { |
| return static_cast<size_t>(field_presence_.MaxSetIndex()) + std::size_t{1}; |
| } |
| |
| static bool IsOrdinalKnown(uint64_t ordinal) { |
| switch (ordinal) { |
| case 1: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| ::fidl::internal::BitSet<1> field_presence_; |
| union ValueUnion_a { |
| ValueUnion_a() {} |
| ~ValueUnion_a() {} |
| |
| uint16_t value; |
| }; |
| ValueUnion_a a_value_; |
| }; |
| |
| using MainProtocolTwoWayAnonWithErrorRequestPtr = ::std::unique_ptr<MainProtocolTwoWayAnonWithErrorRequest>; |
| |
| |
| |
| class MainProtocol_TwoWayAnonWithError_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| MainProtocol_TwoWayAnonWithError_Response(); |
| ~MainProtocol_TwoWayAnonWithError_Response(); |
| |
| MainProtocol_TwoWayAnonWithError_Response(MainProtocol_TwoWayAnonWithError_Response&&); |
| MainProtocol_TwoWayAnonWithError_Response& operator=(MainProtocol_TwoWayAnonWithError_Response&&); |
| |
| |
| static MainProtocol_TwoWayAnonWithError_Response WithB(bool&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kB = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<MainProtocol_TwoWayAnonWithError_Response> New() { return ::std::make_unique<MainProtocol_TwoWayAnonWithError_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocol_TwoWayAnonWithError_Response* value, size_t offset); |
| zx_status_t Clone(MainProtocol_TwoWayAnonWithError_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kB; } |
| |
| bool& b() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kB); |
| return b_; |
| } |
| |
| const bool& b() const { |
| ZX_ASSERT(is_b()); |
| return b_; |
| } |
| MainProtocol_TwoWayAnonWithError_Response& set_b(bool value); |
| MainProtocol_TwoWayAnonWithError_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::Invalid: |
| case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kB: |
| return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag(tag_); |
| default: |
| return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::Invalid); |
| union { |
| bool b_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& value, |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using MainProtocol_TwoWayAnonWithError_ResponsePtr = ::std::unique_ptr<MainProtocol_TwoWayAnonWithError_Response>; |
| |
| |
| |
| class MainProtocol_TwoWayAnonWithError_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| MainProtocol_TwoWayAnonWithError_Result(); |
| ~MainProtocol_TwoWayAnonWithError_Result(); |
| |
| MainProtocol_TwoWayAnonWithError_Result(MainProtocol_TwoWayAnonWithError_Result&&); |
| MainProtocol_TwoWayAnonWithError_Result& operator=(MainProtocol_TwoWayAnonWithError_Result&&); |
| |
| |
| static MainProtocol_TwoWayAnonWithError_Result WithResponse(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response&&); |
| static MainProtocol_TwoWayAnonWithError_Result WithErr(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<MainProtocol_TwoWayAnonWithError_Result> New() { return ::std::make_unique<MainProtocol_TwoWayAnonWithError_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocol_TwoWayAnonWithError_Result* value, size_t offset); |
| zx_status_t Clone(MainProtocol_TwoWayAnonWithError_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse; } |
| |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& response() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| MainProtocol_TwoWayAnonWithError_Result& set_response(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response value); |
| |
| bool is_err() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kErr; } |
| |
| uint32_t& err() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const uint32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| MainProtocol_TwoWayAnonWithError_Result& set_err(uint32_t value); |
| |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag Which() const { |
| |
| return ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result>; |
| MainProtocol_TwoWayAnonWithError_Result(fpromise::ok_result<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>&& result) { |
| set_response(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response{std::move(result.value)}); |
| } |
| MainProtocol_TwoWayAnonWithError_Result(fpromise::error_result<uint32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| MainProtocol_TwoWayAnonWithError_Result(fpromise::result<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response, uint32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response, uint32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response> value_tuple = std::move(response()); |
| return fpromise::ok(std::move(std::get<0>(value_tuple))); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::Invalid); |
| union { |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response response_; |
| uint32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result& value, |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using MainProtocol_TwoWayAnonWithError_ResultPtr = ::std::unique_ptr<MainProtocol_TwoWayAnonWithError_Result>; |
| |
| |
| |
| class MainProtocolOnAnonRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| MainProtocolOnAnonRequest(); |
| ~MainProtocolOnAnonRequest(); |
| |
| MainProtocolOnAnonRequest(MainProtocolOnAnonRequest&&); |
| MainProtocolOnAnonRequest& operator=(MainProtocolOnAnonRequest&&); |
| |
| |
| static MainProtocolOnAnonRequest WithB(bool&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kB = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<MainProtocolOnAnonRequest> New() { return ::std::make_unique<MainProtocolOnAnonRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, MainProtocolOnAnonRequest* value, size_t offset); |
| zx_status_t Clone(MainProtocolOnAnonRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_b() const { return tag_ == ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kB; } |
| |
| bool& b() { |
| EnsureStorageInitialized(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kB); |
| return b_; |
| } |
| |
| const bool& b() const { |
| ZX_ASSERT(is_b()); |
| return b_; |
| } |
| MainProtocolOnAnonRequest& set_b(bool value); |
| MainProtocolOnAnonRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::Invalid: |
| case ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kB: |
| return ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag(tag_); |
| default: |
| return ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::Invalid); |
| union { |
| bool b_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest& value, |
| ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using MainProtocolOnAnonRequestPtr = ::std::unique_ptr<MainProtocolOnAnonRequest>; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolOneWayAnonRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolTwoWayAnonRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolTwoWayAnonWithErrorRequestTable; |
| |
| |
| } // namespace _internal |
| |
| class MainProtocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage OneWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest* ComposedProtocolOneWayAnonComposedRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolOneWayAnonComposedRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest* ComposedProtocolTwoWayAnonComposedRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest* ComposedProtocolTwoWayAnonComposedWithErrorRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedWithErrorRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OneWayNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::UnionPayload* UnionPayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnionPayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OneWayLocal(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayLocal(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::UnionPayload* UnionPayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnionPayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayLocalWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OneWayAnon(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest* MainProtocolOneWayAnonRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, MainProtocolOneWayAnonRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnon(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest* MainProtocolTwoWayAnonRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, MainProtocolTwoWayAnonRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest* MainProtocolTwoWayAnonWithErrorRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, MainProtocolTwoWayAnonWithErrorRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocol_TwoWayLocalWithError_ResultTable; |
| |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolTwoWayAnonResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocol_TwoWayAnonWithError_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_protocollayoutssamelibrary_MainProtocolOnAnonRequestTable; |
| |
| } // namespace _internal |
| |
| class MainProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* ComposedProtocolTwoWayAnonComposedResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolTwoWayAnonComposedResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* ComposedProtocol_TwoWayAnonComposedWithError_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocol_TwoWayAnonComposedWithError_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnAnonComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest* ComposedProtocolOnAnonComposedRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocolOnAnonComposedRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayNamedComposedWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* ComposedProtocol_TwoWayNamedComposedWithError_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, ComposedProtocol_TwoWayNamedComposedWithError_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnNamedComposed(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::UnionPayload* UnionPayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnionPayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayLocal(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::TablePayload* TablePayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, TablePayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayLocalWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result* MainProtocol_TwoWayLocalWithError_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, MainProtocol_TwoWayLocalWithError_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnLocal(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::UnionPayload* UnionPayload) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnionPayload, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnon(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse* MainProtocolTwoWayAnonResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, MainProtocolTwoWayAnonResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage TwoWayAnonWithError(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result* MainProtocol_TwoWayAnonWithError_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, MainProtocol_TwoWayAnonWithError_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage OnAnon(::fidl::MessageEncoder* _encoder, ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest* MainProtocolOnAnonRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, MainProtocolOnAnonRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| } // namespace protocollayoutssamelibrary |
| } // namespace test |
| namespace fidl { |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::TablePayload> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::TablePayload, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::TablePayload& _value, |
| ::test::protocollayoutssamelibrary::TablePayload* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::TablePayload> { |
| bool operator()(const ::test::protocollayoutssamelibrary::TablePayload& _lhs, const ::test::protocollayoutssamelibrary::TablePayload& _rhs) const { |
| if (_lhs.has_a()) { |
| if (!_rhs.has_a()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.a(), _rhs.a())) { |
| return false; |
| } |
| } else if (_rhs.has_a()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::UnionPayload> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::UnionPayload> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::UnionPayload, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::UnionPayload>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::UnionPayload>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::UnionPayload>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::UnionPayload); |
| |
| ::test::protocollayoutssamelibrary::UnionPayload::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::UnionPayload& value, |
| ::test::protocollayoutssamelibrary::UnionPayload* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::UnionPayload> { |
| bool operator()(const ::test::protocollayoutssamelibrary::UnionPayload& _lhs, const ::test::protocollayoutssamelibrary::UnionPayload& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::UnionPayload::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::UnionPayload::Tag::kB: |
| return ::fidl::Equals(_lhs.b_, _rhs.b_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest& _value, |
| ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest& _rhs) const { |
| if (_lhs.has_a()) { |
| if (!_rhs.has_a()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.a(), _rhs.a())) { |
| return false; |
| } |
| } else if (_rhs.has_a()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest::Tag::kB: |
| return ::fidl::Equals(_lhs.b_, _rhs.b_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse& _value, |
| ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse& _rhs) const { |
| if (_lhs.has_a()) { |
| if (!_rhs.has_a()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.a(), _rhs.a())) { |
| return false; |
| } |
| } else if (_rhs.has_a()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest& _value, |
| ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest& _rhs) const { |
| if (_lhs.has_a()) { |
| if (!_rhs.has_a()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.a(), _rhs.a())) { |
| return false; |
| } |
| } else if (_rhs.has_a()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Response::Tag::kB: |
| return ::fidl::Equals(_lhs.b_, _rhs.b_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest::Tag::kB: |
| return ::fidl::Equals(_lhs.b_, _rhs.b_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result); |
| |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result& value, |
| ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result> { |
| bool operator()(const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result& _lhs, const ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result); |
| |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result& value, |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result& _lhs, const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest& _value, |
| ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest& _rhs) const { |
| if (_lhs.has_a()) { |
| if (!_rhs.has_a()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.a(), _rhs.a())) { |
| return false; |
| } |
| } else if (_rhs.has_a()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest); |
| |
| ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest& value, |
| ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest::Tag::kB: |
| return ::fidl::Equals(_lhs.b_, _rhs.b_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse& _value, |
| ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse& _rhs) const { |
| if (_lhs.has_a()) { |
| if (!_rhs.has_a()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.a(), _rhs.a())) { |
| return false; |
| } |
| } else if (_rhs.has_a()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest& _value, |
| ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest& _rhs) const { |
| if (_lhs.has_a()) { |
| if (!_rhs.has_a()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.a(), _rhs.a())) { |
| return false; |
| } |
| } else if (_rhs.has_a()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response); |
| |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& value, |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& _lhs, const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Response::Tag::kB: |
| return ::fidl::Equals(_lhs.b_, _rhs.b_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result); |
| |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result& value, |
| ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result& _lhs, const ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest> |
| : public EncodableCodingTraits<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest); |
| |
| ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest& value, |
| ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest* result) { |
| return ::test::protocollayoutssamelibrary::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest> { |
| bool operator()(const ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest& _lhs, const ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::Invalid): |
| return true; |
| case ::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest::Tag::kB: |
| return ::fidl::Equals(_lhs.b_, _rhs.b_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| |
| // |
| // Proxies and stubs declarations |
| // |
| } // namespace fidl |
| namespace test { |
| namespace protocollayoutssamelibrary { |
| |
| #ifdef __Fuchsia__ |
| |
| using ComposedProtocolPtr = ::fidl::InterfacePtr<ComposedProtocol>; |
| class ComposedProtocol_Proxy; |
| class ComposedProtocol_Stub; |
| class ComposedProtocol_EventSender; |
| class ComposedProtocol_Sync; |
| using ComposedProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<ComposedProtocol>; |
| class ComposedProtocol_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kComposedProtocol_OneWayAnonComposed_Ordinal = 0x6e7a205bdad7941flu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OneWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kComposedProtocol_TwoWayAnonComposed_Ordinal = 0x7083713dee9435f4lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kComposedProtocol_TwoWayAnonComposedWithError_Ordinal = 0x4fd32c5e2ffa6828lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayAnonComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kComposedProtocol_OnAnonComposed_Ordinal = 0x49a6eee3a0300e28lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OnAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kComposedProtocol_OneWayNamedComposed_Ordinal = 0x101636a8fa3e69b8lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OneWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kComposedProtocol_TwoWayNamedComposed_Ordinal = 0x45b4d3d31b374054lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kComposedProtocol_TwoWayNamedComposedWithError_Ordinal = 0x450531e2d20c52eflu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_TwoWayNamedComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kComposedProtocol_OnNamedComposed_Ordinal = 0x17c4edb4a4a36d7blu; |
| |
| constexpr ::fidl::MessageDynamicFlags kComposedProtocol_OnNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;} // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| #ifdef __Fuchsia__ |
| |
| using MainProtocolPtr = ::fidl::InterfacePtr<MainProtocol>; |
| class MainProtocol_Proxy; |
| class MainProtocol_Stub; |
| class MainProtocol_EventSender; |
| class MainProtocol_Sync; |
| using MainProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<MainProtocol>; |
| class MainProtocol_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kMainProtocol_OneWayAnonComposed_Ordinal = 0x6e7a205bdad7941flu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayAnonComposed_Ordinal = 0x7083713dee9435f4lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayAnonComposedWithError_Ordinal = 0x4fd32c5e2ffa6828lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_OnAnonComposed_Ordinal = 0x49a6eee3a0300e28lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnAnonComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_OneWayNamedComposed_Ordinal = 0x101636a8fa3e69b8lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayNamedComposed_Ordinal = 0x45b4d3d31b374054lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayNamedComposedWithError_Ordinal = 0x450531e2d20c52eflu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_OnNamedComposed_Ordinal = 0x17c4edb4a4a36d7blu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnNamedComposed_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_OneWayLocal_Ordinal = 0x3954b4c6b80956c1lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayLocal_Ordinal = 0x26998b4c1e8a9a57lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayLocalWithError_Ordinal = 0x4a7bf9ce881afde7lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayLocalWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_OnLocal_Ordinal = 0x71e90a3d364d2e8dlu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnLocal_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_OneWayAnon_Ordinal = 0x774bf445f584ce2clu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OneWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayAnon_Ordinal = 0x3fd7ad8e52b07e2elu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_TwoWayAnonWithError_Ordinal = 0x1d33061a424eb245lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_TwoWayAnonWithError_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kMainProtocol_OnAnon_Ordinal = 0xd8fa6d0f5fabb94lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kMainProtocol_OnAnon_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;} // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class ComposedProtocol { |
| public: |
| using Proxy_ = ::test::protocollayoutssamelibrary::ComposedProtocol_Proxy; |
| using Stub_ = ::test::protocollayoutssamelibrary::ComposedProtocol_Stub; |
| using EventSender_ = ::test::protocollayoutssamelibrary::ComposedProtocol_EventSender; |
| using Sync_ = ::test::protocollayoutssamelibrary::ComposedProtocol_Sync; |
| virtual ~ComposedProtocol(); |
| |
| virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0; |
| using TwoWayAnonComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse)>; |
| |
| virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) = 0; |
| using TwoWayAnonComposedWithErrorCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result)>; |
| |
| virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) = 0; |
| using OnAnonComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest)>; |
| |
| virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| using TwoWayNamedComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::TablePayload)>; |
| |
| virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) = 0; |
| using TwoWayNamedComposedWithErrorCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result)>; |
| |
| virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) = 0; |
| using OnNamedComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::UnionPayload)>; |
| |
| |
| }; |
| |
| class ComposedProtocol_RequestDecoder { |
| public: |
| ComposedProtocol_RequestDecoder() = default; |
| virtual ~ComposedProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0; |
| virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) = 0; |
| virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) = 0; |
| virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| }; |
| |
| class ComposedProtocol_ResponseDecoder { |
| public: |
| ComposedProtocol_ResponseDecoder() = default; |
| virtual ~ComposedProtocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) = 0; |
| virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0; |
| virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0; |
| virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0; |
| virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| }; |
| |
| class ComposedProtocol_EventSender { |
| public: |
| virtual ~ComposedProtocol_EventSender(); |
| virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0; |
| virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| }; |
| |
| class ComposedProtocol_Sync { |
| public: |
| using Proxy_ = ::test::protocollayoutssamelibrary::ComposedProtocol_SyncProxy; |
| virtual ~ComposedProtocol_Sync(); |
| virtual zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0; |
| virtual zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) = 0; |
| virtual zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0; |
| virtual zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) = 0; |
| virtual zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0; |
| }; |
| |
| class ComposedProtocol_Proxy final : public ::fidl::internal::Proxy, public ComposedProtocol { |
| public: |
| explicit ComposedProtocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~ComposedProtocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayAnonComposed |
| void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposed |
| void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposedWithError |
| void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) override; |
| OnAnonComposedCallback OnAnonComposed; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayNamedComposed |
| void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposed |
| void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposedWithError |
| void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) override; |
| OnNamedComposedCallback OnNamedComposed; |
| |
| |
| |
| |
| private: |
| ComposedProtocol_Proxy(const ::test::protocollayoutssamelibrary::ComposedProtocol_Proxy&) = delete; |
| ComposedProtocol_Proxy& operator=(const ::test::protocollayoutssamelibrary::ComposedProtocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class ComposedProtocol_Stub final : public ::fidl::internal::Stub, public ::test::protocollayoutssamelibrary::ComposedProtocol_EventSender { |
| public: |
| typedef class ::test::protocollayoutssamelibrary::ComposedProtocol ComposedProtocol_clazz; |
| explicit ComposedProtocol_Stub(::test::protocollayoutssamelibrary::ComposedProtocol_Stub::ComposedProtocol_clazz* impl); |
| ~ComposedProtocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) override; |
| void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) override; |
| |
| private: |
| ::test::protocollayoutssamelibrary::ComposedProtocol_Stub::ComposedProtocol_clazz* impl_; |
| }; |
| |
| class ComposedProtocol_SyncProxy : public ::test::protocollayoutssamelibrary::ComposedProtocol_Sync { |
| public: |
| explicit ComposedProtocol_SyncProxy(::zx::channel channel); |
| ~ComposedProtocol_SyncProxy() override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayAnonComposed |
| zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposed |
| zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayAnonComposedWithError |
| zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.OneWayNamedComposed |
| zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposed |
| zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/ComposedProtocol.TwoWayNamedComposedWithError |
| zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<ComposedProtocol>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class MainProtocol { |
| public: |
| using Proxy_ = ::test::protocollayoutssamelibrary::MainProtocol_Proxy; |
| using Stub_ = ::test::protocollayoutssamelibrary::MainProtocol_Stub; |
| using EventSender_ = ::test::protocollayoutssamelibrary::MainProtocol_EventSender; |
| using Sync_ = ::test::protocollayoutssamelibrary::MainProtocol_Sync; |
| virtual ~MainProtocol(); |
| |
| virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0; |
| using TwoWayAnonComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse)>; |
| |
| virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) = 0; |
| using TwoWayAnonComposedWithErrorCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result)>; |
| |
| virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) = 0; |
| using OnAnonComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest)>; |
| |
| virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| using TwoWayNamedComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::TablePayload)>; |
| |
| virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) = 0; |
| using TwoWayNamedComposedWithErrorCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result)>; |
| |
| virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) = 0; |
| using OnNamedComposedCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::UnionPayload)>; |
| |
| virtual void OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| using TwoWayLocalCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::TablePayload)>; |
| |
| virtual void TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayLocalCallback callback) = 0; |
| using TwoWayLocalWithErrorCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result)>; |
| |
| virtual void TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayLocalWithErrorCallback callback) = 0; |
| using OnLocalCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::UnionPayload)>; |
| |
| virtual void OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0; |
| using TwoWayAnonCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse)>; |
| |
| virtual void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, TwoWayAnonCallback callback) = 0; |
| using TwoWayAnonWithErrorCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result)>; |
| |
| virtual void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, TwoWayAnonWithErrorCallback callback) = 0; |
| using OnAnonCallback = |
| fit::function<void(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest)>; |
| |
| |
| }; |
| |
| class MainProtocol_RequestDecoder { |
| public: |
| MainProtocol_RequestDecoder() = default; |
| virtual ~MainProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0; |
| virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest) = 0; |
| virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest) = 0; |
| virtual void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| virtual void TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0; |
| virtual void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest) = 0; |
| virtual void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest) = 0; |
| }; |
| |
| class MainProtocol_ResponseDecoder { |
| public: |
| MainProtocol_ResponseDecoder() = default; |
| virtual ~MainProtocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse ComposedProtocolTwoWayAnonComposedResponse) = 0; |
| virtual void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0; |
| virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0; |
| virtual void TwoWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0; |
| virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| virtual void TwoWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual void TwoWayLocalWithError(::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result MainProtocol_TwoWayLocalWithError_Result) = 0; |
| virtual void OnLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| virtual void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse MainProtocolTwoWayAnonResponse) = 0; |
| virtual void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result MainProtocol_TwoWayAnonWithError_Result) = 0; |
| virtual void OnAnon(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) = 0; |
| }; |
| |
| class MainProtocol_EventSender { |
| public: |
| virtual ~MainProtocol_EventSender(); |
| virtual void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) = 0; |
| virtual void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| virtual void OnLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) = 0; |
| virtual void OnAnon(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) = 0; |
| }; |
| |
| class MainProtocol_Sync { |
| public: |
| using Proxy_ = ::test::protocollayoutssamelibrary::MainProtocol_SyncProxy; |
| virtual ~MainProtocol_Sync(); |
| virtual zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) = 0; |
| virtual zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) = 0; |
| virtual zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) = 0; |
| virtual zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) = 0; |
| virtual zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) = 0; |
| virtual zx_status_t OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) = 0; |
| virtual zx_status_t TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) = 0; |
| virtual zx_status_t TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) = 0; |
| virtual zx_status_t OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) = 0; |
| virtual zx_status_t TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse* out_MainProtocolTwoWayAnonResponse) = 0; |
| virtual zx_status_t TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result* out_MainProtocol_TwoWayAnonWithError_Result) = 0; |
| }; |
| |
| class MainProtocol_Proxy final : public ::fidl::internal::Proxy, public MainProtocol { |
| public: |
| explicit MainProtocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~MainProtocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnonComposed |
| void OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposed |
| void TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, TwoWayAnonComposedCallback callback) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposedWithError |
| void TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, TwoWayAnonComposedWithErrorCallback callback) override; |
| OnAnonComposedCallback OnAnonComposed; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayNamedComposed |
| void OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposed |
| void TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayNamedComposedCallback callback) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposedWithError |
| void TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayNamedComposedWithErrorCallback callback) override; |
| OnNamedComposedCallback OnNamedComposed; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayLocal |
| void OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocal |
| void TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, TwoWayLocalCallback callback) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocalWithError |
| void TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, TwoWayLocalWithErrorCallback callback) override; |
| OnLocalCallback OnLocal; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnon |
| void OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnon |
| void TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, TwoWayAnonCallback callback) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonWithError |
| void TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, TwoWayAnonWithErrorCallback callback) override; |
| OnAnonCallback OnAnon; |
| |
| |
| |
| |
| private: |
| MainProtocol_Proxy(const ::test::protocollayoutssamelibrary::MainProtocol_Proxy&) = delete; |
| MainProtocol_Proxy& operator=(const ::test::protocollayoutssamelibrary::MainProtocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class MainProtocol_Stub final : public ::fidl::internal::Stub, public ::test::protocollayoutssamelibrary::MainProtocol_EventSender { |
| public: |
| typedef class ::test::protocollayoutssamelibrary::MainProtocol MainProtocol_clazz; |
| explicit MainProtocol_Stub(::test::protocollayoutssamelibrary::MainProtocol_Stub::MainProtocol_clazz* impl); |
| ~MainProtocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| void OnAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOnAnonComposedRequest ComposedProtocolOnAnonComposedRequest) override; |
| void OnNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) override; |
| void OnLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload) override; |
| void OnAnon(::test::protocollayoutssamelibrary::MainProtocolOnAnonRequest MainProtocolOnAnonRequest) override; |
| |
| private: |
| ::test::protocollayoutssamelibrary::MainProtocol_Stub::MainProtocol_clazz* impl_; |
| }; |
| |
| class MainProtocol_SyncProxy : public ::test::protocollayoutssamelibrary::MainProtocol_Sync { |
| public: |
| explicit MainProtocol_SyncProxy(::zx::channel channel); |
| ~MainProtocol_SyncProxy() override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnonComposed |
| zx_status_t OneWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolOneWayAnonComposedRequest ComposedProtocolOneWayAnonComposedRequest) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposed |
| zx_status_t TwoWayAnonComposed(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedRequest ComposedProtocolTwoWayAnonComposedRequest, ::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedResponse* out_ComposedProtocolTwoWayAnonComposedResponse) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonComposedWithError |
| zx_status_t TwoWayAnonComposedWithError(::test::protocollayoutssamelibrary::ComposedProtocolTwoWayAnonComposedWithErrorRequest ComposedProtocolTwoWayAnonComposedWithErrorRequest, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayAnonComposedWithError_Result* out_ComposedProtocol_TwoWayAnonComposedWithError_Result) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayNamedComposed |
| zx_status_t OneWayNamedComposed(::test::protocollayoutssamelibrary::TablePayload TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposed |
| zx_status_t TwoWayNamedComposed(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayNamedComposedWithError |
| zx_status_t TwoWayNamedComposedWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::ComposedProtocol_TwoWayNamedComposedWithError_Result* out_ComposedProtocol_TwoWayNamedComposedWithError_Result) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayLocal |
| zx_status_t OneWayLocal(::test::protocollayoutssamelibrary::TablePayload TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocal |
| zx_status_t TwoWayLocal(::test::protocollayoutssamelibrary::UnionPayload UnionPayload, ::test::protocollayoutssamelibrary::TablePayload* out_TablePayload) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayLocalWithError |
| zx_status_t TwoWayLocalWithError(::test::protocollayoutssamelibrary::TablePayload TablePayload, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayLocalWithError_Result* out_MainProtocol_TwoWayLocalWithError_Result) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.OneWayAnon |
| zx_status_t OneWayAnon(::test::protocollayoutssamelibrary::MainProtocolOneWayAnonRequest MainProtocolOneWayAnonRequest) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnon |
| zx_status_t TwoWayAnon(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonRequest MainProtocolTwoWayAnonRequest, ::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonResponse* out_MainProtocolTwoWayAnonResponse) override; |
| // cts-coverage-fidl-name:test.protocollayoutssamelibrary/MainProtocol.TwoWayAnonWithError |
| zx_status_t TwoWayAnonWithError(::test::protocollayoutssamelibrary::MainProtocolTwoWayAnonWithErrorRequest MainProtocolTwoWayAnonWithErrorRequest, ::test::protocollayoutssamelibrary::MainProtocol_TwoWayAnonWithError_Result* out_MainProtocol_TwoWayAnonWithError_Result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<MainProtocol>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| } // namespace protocollayoutssamelibrary |
| } // namespace test |
| |
| |