| // 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 unknowninteractions { |
| |
| |
| // |
| // Domain objects declarations |
| // |
| |
| |
| class UnknownInteractionsProtocolStrictTwoWayFieldsResponse; |
| |
| |
| class UnknownInteractionsProtocolStrictTwoWayUnionResponse; |
| |
| |
| class UnknownInteractionsProtocolStrictTwoWayTableResponse; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayTableErr_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWay_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWay_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFields_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFields_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTable_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTable_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result; |
| |
| |
| class UnknownInteractionsProtocolStrictEventFieldsRequest; |
| |
| |
| class UnknownInteractionsProtocolStrictEventUnionRequest; |
| |
| |
| class UnknownInteractionsProtocolStrictEventTableRequest; |
| |
| |
| class UnknownInteractionsProtocolFlexibleEventFieldsRequest; |
| |
| |
| class UnknownInteractionsProtocolFlexibleEventUnionRequest; |
| |
| |
| class UnknownInteractionsProtocolFlexibleEventTableRequest; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsProtocol; |
| using UnknownInteractionsProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsProtocol>; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| class UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse; |
| |
| |
| class UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse; |
| |
| |
| class UnknownInteractionsAjarProtocolStrictTwoWayTableResponse; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result; |
| |
| |
| class UnknownInteractionsAjarProtocolStrictEventFieldsRequest; |
| |
| |
| class UnknownInteractionsAjarProtocolStrictEventUnionRequest; |
| |
| |
| class UnknownInteractionsAjarProtocolStrictEventTableRequest; |
| |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest; |
| |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventUnionRequest; |
| |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventTableRequest; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsAjarProtocol; |
| using UnknownInteractionsAjarProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsAjarProtocol>; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| class UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse; |
| |
| |
| class UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse; |
| |
| |
| class UnknownInteractionsClosedProtocolStrictTwoWayTableResponse; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result; |
| |
| |
| class UnknownInteractionsClosedProtocolStrictEventFieldsRequest; |
| |
| |
| class UnknownInteractionsClosedProtocolStrictEventUnionRequest; |
| |
| |
| class UnknownInteractionsClosedProtocolStrictEventTableRequest; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsClosedProtocol; |
| using UnknownInteractionsClosedProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsClosedProtocol>; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| class UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse; |
| |
| |
| class UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse; |
| |
| |
| class UnknownInteractionsDriverProtocolStrictTwoWayTableResponse; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result; |
| |
| |
| class UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse; |
| |
| |
| class UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse; |
| |
| |
| class UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result; |
| |
| |
| class UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse; |
| |
| |
| class UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse; |
| |
| |
| class UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response; |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result; |
| |
| |
| |
| class UnknownInteractionsProtocolStrictTwoWayFieldsResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayFieldsResponse> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictTwoWayFieldsResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictTwoWayFieldsResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictTwoWayFieldsResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayFieldsResponse>; |
| |
| |
| |
| class UnknownInteractionsProtocolStrictTwoWayUnionResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocolStrictTwoWayUnionResponse(); |
| ~UnknownInteractionsProtocolStrictTwoWayUnionResponse(); |
| |
| UnknownInteractionsProtocolStrictTwoWayUnionResponse(UnknownInteractionsProtocolStrictTwoWayUnionResponse&&); |
| UnknownInteractionsProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsProtocolStrictTwoWayUnionResponse&&); |
| |
| |
| static UnknownInteractionsProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayUnionResponse> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictTwoWayUnionResponse>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictTwoWayUnionResponse* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictTwoWayUnionResponse* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value); |
| UnknownInteractionsProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::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::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayUnionResponse>; |
| |
| |
| |
| class UnknownInteractionsProtocolStrictTwoWayTableResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsProtocolStrictTwoWayTableResponse(UnknownInteractionsProtocolStrictTwoWayTableResponse&& other); |
| ~UnknownInteractionsProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsProtocolStrictTwoWayTableResponse&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayTableResponse> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictTwoWayTableResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictTwoWayTableResponse* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictTwoWayTableResponse* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayTableResponse>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_StrictTwoWayErr_Response() = default; |
| explicit UnknownInteractionsProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result(); |
| ~UnknownInteractionsProtocol_StrictTwoWayErr_Result(); |
| |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result(UnknownInteractionsProtocol_StrictTwoWayErr_Result&&); |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response&&); |
| static UnknownInteractionsProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result>; |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response{}); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result&&); |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>; |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response(); |
| ~UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response&&); |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(); |
| ~UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result&&); |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response&&); |
| static UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>; |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsProtocol_StrictTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsProtocol_StrictTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_StrictTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(); |
| ~UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(); |
| |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsProtocol_StrictTwoWayTableErr_Result&&); |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsProtocol_StrictTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response&&); |
| static UnknownInteractionsProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>; |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWay_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_FlexibleTwoWay_Response() = default; |
| explicit UnknownInteractionsProtocol_FlexibleTwoWay_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsProtocol_FlexibleTwoWay_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWay_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWay_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWay_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWay_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWay_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWay_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWay_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWay_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWay_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWay_Result(UnknownInteractionsProtocol_FlexibleTwoWay_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWay_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWay_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWay_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWay_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWay_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWay_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWay_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWay_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWay_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWay_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWay_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response{}); |
| } |
| operator fpromise::result<void, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWay_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWay_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFields_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_FlexibleTwoWayFields_Response() = default; |
| explicit UnknownInteractionsProtocol_FlexibleTwoWayFields_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsProtocol_FlexibleTwoWayFields_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFields_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayFields_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayFields_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayFields_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayFields_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFields_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFields_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayFields_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayFields_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayFields_Result(UnknownInteractionsProtocol_FlexibleTwoWayFields_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayFields_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayFields_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayFields_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFields_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWayFields_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response{std::move(result.value)}); |
| } |
| operator fpromise::result<int32_t, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayFields_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& set_some_field(int32_t value); |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayUnion_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response{std::move(result.value)}); |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayUnion_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTable_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Response(); |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Response(UnknownInteractionsProtocol_FlexibleTwoWayTable_Response&& other); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayTable_Response(); |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTable_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTable_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayTable_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayTable_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayTable_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayTable_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTable_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTable_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayTable_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Result(UnknownInteractionsProtocol_FlexibleTwoWayTable_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTable_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayTable_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayTable_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTable_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWayTable_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response{std::move(result.value)}); |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayTable_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Response() = default; |
| explicit UnknownInteractionsProtocol_FlexibleTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsProtocol_FlexibleTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayErr_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response{}); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response(); |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response(); |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(); |
| ~UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result&&); |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& operator=(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>; |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>; |
| |
| |
| |
| class UnknownInteractionsProtocolStrictEventFieldsRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictEventFieldsRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictEventFieldsRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictEventFieldsRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictEventFieldsRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolStrictEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictEventFieldsRequest>; |
| |
| |
| |
| class UnknownInteractionsProtocolStrictEventUnionRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocolStrictEventUnionRequest(); |
| ~UnknownInteractionsProtocolStrictEventUnionRequest(); |
| |
| UnknownInteractionsProtocolStrictEventUnionRequest(UnknownInteractionsProtocolStrictEventUnionRequest&&); |
| UnknownInteractionsProtocolStrictEventUnionRequest& operator=(UnknownInteractionsProtocolStrictEventUnionRequest&&); |
| |
| |
| static UnknownInteractionsProtocolStrictEventUnionRequest WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictEventUnionRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictEventUnionRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictEventUnionRequest* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictEventUnionRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsProtocolStrictEventUnionRequest& set_some_field(int32_t value); |
| UnknownInteractionsProtocolStrictEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::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::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocolStrictEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictEventUnionRequest>; |
| |
| |
| |
| class UnknownInteractionsProtocolStrictEventTableRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsProtocolStrictEventTableRequest& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsProtocolStrictEventTableRequest(); |
| UnknownInteractionsProtocolStrictEventTableRequest(UnknownInteractionsProtocolStrictEventTableRequest&& other); |
| ~UnknownInteractionsProtocolStrictEventTableRequest(); |
| UnknownInteractionsProtocolStrictEventTableRequest& operator=(UnknownInteractionsProtocolStrictEventTableRequest&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictEventTableRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictEventTableRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictEventTableRequest* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictEventTableRequest* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsProtocolStrictEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictEventTableRequest>; |
| |
| |
| |
| class UnknownInteractionsProtocolFlexibleEventFieldsRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventFieldsRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolFlexibleEventFieldsRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolFlexibleEventFieldsRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolFlexibleEventFieldsRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolFlexibleEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventFieldsRequest>; |
| |
| |
| |
| class UnknownInteractionsProtocolFlexibleEventUnionRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocolFlexibleEventUnionRequest(); |
| ~UnknownInteractionsProtocolFlexibleEventUnionRequest(); |
| |
| UnknownInteractionsProtocolFlexibleEventUnionRequest(UnknownInteractionsProtocolFlexibleEventUnionRequest&&); |
| UnknownInteractionsProtocolFlexibleEventUnionRequest& operator=(UnknownInteractionsProtocolFlexibleEventUnionRequest&&); |
| |
| |
| static UnknownInteractionsProtocolFlexibleEventUnionRequest WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventUnionRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolFlexibleEventUnionRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolFlexibleEventUnionRequest* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocolFlexibleEventUnionRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsProtocolFlexibleEventUnionRequest& set_some_field(int32_t value); |
| UnknownInteractionsProtocolFlexibleEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::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::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocolFlexibleEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventUnionRequest>; |
| |
| |
| |
| class UnknownInteractionsProtocolFlexibleEventTableRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsProtocolFlexibleEventTableRequest& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsProtocolFlexibleEventTableRequest(); |
| UnknownInteractionsProtocolFlexibleEventTableRequest(UnknownInteractionsProtocolFlexibleEventTableRequest&& other); |
| ~UnknownInteractionsProtocolFlexibleEventTableRequest(); |
| UnknownInteractionsProtocolFlexibleEventTableRequest& operator=(UnknownInteractionsProtocolFlexibleEventTableRequest&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventTableRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolFlexibleEventTableRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolFlexibleEventTableRequest* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolFlexibleEventTableRequest* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsProtocolFlexibleEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventTableRequest>; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| class UnknownInteractionsProtocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictOneWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleOneWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayFields(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayUnion(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayTable(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayUnionErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayTableErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayFieldsResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayUnionResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayTableResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayFieldsErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayUnionErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_StrictTwoWayTableErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWay_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayFields_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayUnion_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayTable_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocol_FlexibleTwoWayTableErr_ResultTable; |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictEventFieldsRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictEventUnionRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictEventTableRequestTable; |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventFieldsRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventUnionRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventTableRequestTable; |
| |
| } // namespace _internal |
| |
| class UnknownInteractionsProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse* UnknownInteractionsProtocolStrictTwoWayUnionResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocolStrictTwoWayUnionResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse* UnknownInteractionsProtocolStrictTwoWayTableResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocolStrictTwoWayTableResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* UnknownInteractionsProtocol_StrictTwoWayErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_StrictTwoWayErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* UnknownInteractionsProtocol_StrictTwoWayTableErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_StrictTwoWayTableErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWay(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* UnknownInteractionsProtocol_FlexibleTwoWay_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWay_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayFields(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* UnknownInteractionsProtocol_FlexibleTwoWayFields_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWayFields_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* UnknownInteractionsProtocol_FlexibleTwoWayTable_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWayTable_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* UnknownInteractionsProtocol_FlexibleTwoWayErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWayErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayFieldsErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayUnionErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayTableErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest* UnknownInteractionsProtocolStrictEventUnionRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocolStrictEventUnionRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest* UnknownInteractionsProtocolStrictEventTableRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocolStrictEventTableRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEvent(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest* UnknownInteractionsProtocolFlexibleEventUnionRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocolFlexibleEventUnionRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest* UnknownInteractionsProtocolFlexibleEventTableRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsProtocolFlexibleEventTableRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| class UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse(); |
| ~UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse(); |
| |
| UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse&&); |
| UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse&&); |
| |
| |
| static UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value); |
| UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::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::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolStrictTwoWayTableResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsAjarProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsAjarProtocolStrictTwoWayTableResponse(UnknownInteractionsAjarProtocolStrictTwoWayTableResponse&& other); |
| ~UnknownInteractionsAjarProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsAjarProtocolStrictTwoWayTableResponse&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsAjarProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayTableResponse>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response() = default; |
| explicit UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(); |
| ~UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(); |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result&&); |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response&&); |
| static UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>; |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response{}); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result&&); |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>; |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response(); |
| ~UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response&&); |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(); |
| ~UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result&&); |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response&&); |
| static UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>; |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(); |
| ~UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(); |
| |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result&&); |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response&&); |
| static UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>; |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolStrictEventFieldsRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventFieldsRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictEventFieldsRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictEventFieldsRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictEventFieldsRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocolStrictEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventFieldsRequest>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolStrictEventUnionRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocolStrictEventUnionRequest(); |
| ~UnknownInteractionsAjarProtocolStrictEventUnionRequest(); |
| |
| UnknownInteractionsAjarProtocolStrictEventUnionRequest(UnknownInteractionsAjarProtocolStrictEventUnionRequest&&); |
| UnknownInteractionsAjarProtocolStrictEventUnionRequest& operator=(UnknownInteractionsAjarProtocolStrictEventUnionRequest&&); |
| |
| |
| static UnknownInteractionsAjarProtocolStrictEventUnionRequest WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventUnionRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictEventUnionRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictEventUnionRequest* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictEventUnionRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsAjarProtocolStrictEventUnionRequest& set_some_field(int32_t value); |
| UnknownInteractionsAjarProtocolStrictEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::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::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocolStrictEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventUnionRequest>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolStrictEventTableRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsAjarProtocolStrictEventTableRequest& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsAjarProtocolStrictEventTableRequest(); |
| UnknownInteractionsAjarProtocolStrictEventTableRequest(UnknownInteractionsAjarProtocolStrictEventTableRequest&& other); |
| ~UnknownInteractionsAjarProtocolStrictEventTableRequest(); |
| UnknownInteractionsAjarProtocolStrictEventTableRequest& operator=(UnknownInteractionsAjarProtocolStrictEventTableRequest&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventTableRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictEventTableRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictEventTableRequest* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictEventTableRequest* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsAjarProtocolStrictEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventTableRequest>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocolFlexibleEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventUnionRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocolFlexibleEventUnionRequest(); |
| ~UnknownInteractionsAjarProtocolFlexibleEventUnionRequest(); |
| |
| UnknownInteractionsAjarProtocolFlexibleEventUnionRequest(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest&&); |
| UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& operator=(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest&&); |
| |
| |
| static UnknownInteractionsAjarProtocolFlexibleEventUnionRequest WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolFlexibleEventUnionRequest* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolFlexibleEventUnionRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& set_some_field(int32_t value); |
| UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::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::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocolFlexibleEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>; |
| |
| |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventTableRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsAjarProtocolFlexibleEventTableRequest& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsAjarProtocolFlexibleEventTableRequest(); |
| UnknownInteractionsAjarProtocolFlexibleEventTableRequest(UnknownInteractionsAjarProtocolFlexibleEventTableRequest&& other); |
| ~UnknownInteractionsAjarProtocolFlexibleEventTableRequest(); |
| UnknownInteractionsAjarProtocolFlexibleEventTableRequest& operator=(UnknownInteractionsAjarProtocolFlexibleEventTableRequest&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventTableRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolFlexibleEventTableRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolFlexibleEventTableRequest* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolFlexibleEventTableRequest* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsAjarProtocolFlexibleEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventTableRequest>; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| class UnknownInteractionsAjarProtocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictOneWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleOneWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayUnionResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayTableResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_ResultTable; |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventFieldsRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventUnionRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventTableRequestTable; |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventFieldsRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventUnionRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventTableRequestTable; |
| |
| } // namespace _internal |
| |
| class UnknownInteractionsAjarProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocolStrictTwoWayTableResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest* UnknownInteractionsAjarProtocolStrictEventUnionRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocolStrictEventUnionRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest* UnknownInteractionsAjarProtocolStrictEventTableRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocolStrictEventTableRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEvent(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest* UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocolFlexibleEventUnionRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest* UnknownInteractionsAjarProtocolFlexibleEventTableRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsAjarProtocolFlexibleEventTableRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| class UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse(); |
| ~UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse(); |
| |
| UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse&&); |
| UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse&&); |
| |
| |
| static UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value); |
| UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::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::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocolStrictTwoWayTableResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsClosedProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsClosedProtocolStrictTwoWayTableResponse(UnknownInteractionsClosedProtocolStrictTwoWayTableResponse&& other); |
| ~UnknownInteractionsClosedProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsClosedProtocolStrictTwoWayTableResponse&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayTableResponse> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsClosedProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayTableResponse>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response() = default; |
| explicit UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(); |
| ~UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(); |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result&&); |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response&&); |
| static UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>; |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response{}); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result&&); |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>; |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response(); |
| ~UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response&&); |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(); |
| ~UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result&&); |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response&&); |
| static UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>; |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(); |
| ~UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(); |
| |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result&&); |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response&&); |
| static UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>; |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocolStrictEventFieldsRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventFieldsRequest> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictEventFieldsRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictEventFieldsRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictEventFieldsRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedProtocolStrictEventFieldsRequestPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventFieldsRequest>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocolStrictEventUnionRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocolStrictEventUnionRequest(); |
| ~UnknownInteractionsClosedProtocolStrictEventUnionRequest(); |
| |
| UnknownInteractionsClosedProtocolStrictEventUnionRequest(UnknownInteractionsClosedProtocolStrictEventUnionRequest&&); |
| UnknownInteractionsClosedProtocolStrictEventUnionRequest& operator=(UnknownInteractionsClosedProtocolStrictEventUnionRequest&&); |
| |
| |
| static UnknownInteractionsClosedProtocolStrictEventUnionRequest WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventUnionRequest> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictEventUnionRequest>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictEventUnionRequest* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictEventUnionRequest* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsClosedProtocolStrictEventUnionRequest& set_some_field(int32_t value); |
| UnknownInteractionsClosedProtocolStrictEventUnionRequest& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::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::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocolStrictEventUnionRequestPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventUnionRequest>; |
| |
| |
| |
| class UnknownInteractionsClosedProtocolStrictEventTableRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsClosedProtocolStrictEventTableRequest& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsClosedProtocolStrictEventTableRequest(); |
| UnknownInteractionsClosedProtocolStrictEventTableRequest(UnknownInteractionsClosedProtocolStrictEventTableRequest&& other); |
| ~UnknownInteractionsClosedProtocolStrictEventTableRequest(); |
| UnknownInteractionsClosedProtocolStrictEventTableRequest& operator=(UnknownInteractionsClosedProtocolStrictEventTableRequest&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventTableRequest> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictEventTableRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictEventTableRequest* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictEventTableRequest* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsClosedProtocolStrictEventTableRequestPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventTableRequest>; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| class UnknownInteractionsClosedProtocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictOneWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayUnionResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayTableResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_ResultTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_ResultTable; |
| |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventFieldsRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventUnionRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventTableRequestTable; |
| |
| } // namespace _internal |
| |
| class UnknownInteractionsClosedProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocolStrictTwoWayTableResponse, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayFieldsErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayUnionErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayTableErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventFields(::fidl::MessageEncoder* _encoder, int32_t* some_field) { |
| _encoder->Alloc(4); |
| ::fidl::Encode(_encoder, some_field, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventUnion(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest* UnknownInteractionsClosedProtocolStrictEventUnionRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocolStrictEventUnionRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventTable(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest* UnknownInteractionsClosedProtocolStrictEventTableRequest) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, UnknownInteractionsClosedProtocolStrictEventTableRequest, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| class UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> New() { return ::std::make_unique<UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse(); |
| ~UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse(); |
| |
| UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse&&); |
| UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse&&); |
| |
| |
| static UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse> New() { return ::std::make_unique<UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value); |
| UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::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::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocolStrictTwoWayTableResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsDriverProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsDriverProtocolStrictTwoWayTableResponse(UnknownInteractionsDriverProtocolStrictTwoWayTableResponse&& other); |
| ~UnknownInteractionsDriverProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsDriverProtocolStrictTwoWayTableResponse&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayTableResponse> New() { return ::std::make_unique<UnknownInteractionsDriverProtocolStrictTwoWayTableResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocolStrictTwoWayTableResponse* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocolStrictTwoWayTableResponse* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsDriverProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayTableResponse>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response() = default; |
| explicit UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(); |
| ~UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result&&); |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response&&); |
| static UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>; |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response{}); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result&&); |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>; |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response(); |
| ~UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(); |
| ~UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result&&); |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| static UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>; |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(); |
| ~UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result&&); |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response&&); |
| static UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>; |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response() = default; |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWay_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response{}); |
| } |
| operator fpromise::result<void, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWay_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response() = default; |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response{std::move(result.value)}); |
| } |
| operator fpromise::result<int32_t, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& set_some_field(int32_t value); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response{std::move(result.value)}); |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response(); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response&& other); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response(); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response{std::move(result.value)}); |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response, ::fidl::FrameworkErr>() && { |
| if (is_framework_err()) { |
| return fpromise::error(framework_err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response response_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response() = default; |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response{}); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response(); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response(); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(); |
| ~UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(); |
| |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result&&); |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& operator=(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result WithErr(int32_t&&); |
| static UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result WithFrameworkErr(::fidl::FrameworkErr&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kFrameworkErr = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& set_err(int32_t value); |
| |
| bool is_framework_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr; } |
| |
| ::fidl::FrameworkErr& framework_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr); |
| return framework_err_; |
| } |
| |
| const ::fidl::FrameworkErr& framework_err() const { |
| ZX_ASSERT(is_framework_err()); |
| return framework_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& set_framework_err(::fidl::FrameworkErr value); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>; |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response, std::variant<int32_t, ::fidl::FrameworkErr>>() && { |
| if (is_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<0>, err())); |
| } |
| if (is_framework_err()) { |
| return fpromise::error(std::variant<int32_t, ::fidl::FrameworkErr>(std::in_place_index<1>, framework_err())); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response response_; |
| int32_t err_; |
| ::fidl::FrameworkErr framework_err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse(); |
| ~UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse(); |
| |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse&&); |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse&&); |
| |
| |
| static UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value); |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::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::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse&& other); |
| ~UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response() = default; |
| explicit UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(); |
| ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(); |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result&&); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response&&); |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>; |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response{}); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result&&); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>; |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response(); |
| ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(); |
| ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result&&); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>; |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(); |
| ~UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(); |
| |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result&&); |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response&&); |
| static UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>; |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse(); |
| ~UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse(); |
| |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse&&); |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& operator=(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse&&); |
| |
| |
| static UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& set_some_field(int32_t value); |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::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::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse&& other); |
| ~UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse(); |
| UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& operator=(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response() = default; |
| explicit UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple( |
| ); |
| } |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(); |
| ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(); |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result&&); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response&&); |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>; |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response{}); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<void, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| return fpromise::ok(); |
| } |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response() = default; |
| explicit UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response(int32_t v) : some_field(std::move(v)) {} |
| int32_t ResultValue_() { return std::move(some_field); } |
| explicit UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response(::std::tuple<int32_t> _value_tuple) { |
| std::tie(some_field) = std::move(_value_tuple); |
| } |
| operator ::std::tuple<int32_t>() && { |
| return std::make_tuple(std::move(some_field) |
| ); |
| } |
| |
| int32_t some_field{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(); |
| ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(); |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result&&); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response&&); |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>; |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::ok_result<int32_t>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result(fpromise::result<int32_t, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<int32_t, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<int32_t> 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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response(); |
| ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response(); |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| |
| |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response WithSomeField(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kSomeField = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_some_field() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField; } |
| |
| int32_t& some_field() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField); |
| return some_field_; |
| } |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(is_some_field()); |
| return some_field_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& set_some_field(int32_t value); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid: |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag(tag_); |
| default: |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid); |
| union { |
| int32_t some_field_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(); |
| ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(); |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result&&); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response&&); |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>; |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| /// Returns whether no field is set. |
| bool IsEmpty() const; |
| |
| const int32_t& some_field() const { |
| ZX_ASSERT(field_presence_.IsSet<0>()); |
| return some_field_value_.value; |
| } |
| bool has_some_field() const { |
| return field_presence_.IsSet<0>(); |
| } |
| |
| int32_t* mutable_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| field_presence_.Set<0>(); |
| Construct(&some_field_value_.value); |
| } |
| return &some_field_value_.value; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& set_some_field(int32_t _value); |
| void clear_some_field() { |
| if (!field_presence_.IsSet<0>()) { |
| return; |
| } |
| field_presence_.Clear<0>(); |
| Destruct(&some_field_value_.value); |
| } |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response&& other); |
| ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response(); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response&& other); |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response* _value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response* _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_some_field { |
| ValueUnion_some_field() {} |
| ~ValueUnion_some_field() {} |
| |
| int32_t value; |
| }; |
| ValueUnion_some_field some_field_value_; |
| }; |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response>; |
| |
| |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(); |
| ~UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(); |
| |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result&&); |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& operator=(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result&&); |
| |
| |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response&&); |
| static UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result WithErr(int32_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<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag Which() const { |
| |
| return ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>; |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(fpromise::ok_result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response>&& result) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response{std::move(result.value)}); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(fpromise::error_result<int32_t>&& result) { |
| set_err(std::move(result.error)); |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result(fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response{result.take_value()}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| operator fpromise::result<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response, int32_t>() && { |
| if (is_err()) { |
| return fpromise::error(err()); |
| } |
| ::std::tuple<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>; |
| |
| |
| } // namespace unknowninteractions |
| } // namespace test |
| namespace fidl { |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayFieldsResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventFieldsRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventFieldsRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayFieldsResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventFieldsRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventFieldsRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayFieldsResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventFieldsRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest>* 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::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayFieldsResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayTableResponse& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFields_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnion_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTable_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayFieldsErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayUnionErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_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::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| case ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayTableErr_Result::Tag::kFrameworkErr: |
| return ::fidl::Equals(_lhs.framework_err_, _rhs.framework_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayFieldsResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayTableResponse& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayFieldsResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse>* 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::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayUnionResponse::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayTableResponse& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response, 4> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response>::value |
| && IsMemcpyCompatible<int32_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.some_field, _rhs.some_field)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayFieldsErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Response::Tag::kSomeField: |
| return ::fidl::Equals(_lhs.some_field_, _rhs.some_field_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayUnionErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response, 16> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response* result) { |
| return _value.Clone(result); |
| } |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Response& _rhs) const { |
| if (_lhs.has_some_field()) { |
| if (!_rhs.has_some_field()) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.some_field(), _rhs.some_field())) { |
| return false; |
| } |
| } else if (_rhs.has_some_field()) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_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::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayTableErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| |
| // |
| // Proxies and stubs declarations |
| // |
| } // namespace fidl |
| namespace test { |
| namespace unknowninteractions { |
| |
| #ifdef __Fuchsia__ |
| |
| using UnknownInteractionsProtocolPtr = ::fidl::InterfacePtr<UnknownInteractionsProtocol>; |
| class UnknownInteractionsProtocol_Proxy; |
| class UnknownInteractionsProtocol_Stub; |
| class UnknownInteractionsProtocol_EventSender; |
| class UnknownInteractionsProtocol_Sync; |
| using UnknownInteractionsProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<UnknownInteractionsProtocol>; |
| class UnknownInteractionsProtocol_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictOneWay_Ordinal = 0x4e7273b964d117a6lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleOneWay_Ordinal = 0x818bb3a7a910446lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWay_Ordinal = 0x734c996b0f37b942lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayFields_Ordinal = 0x334f4e7fff460ae3lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayUnion_Ordinal = 0x2212805eca592cadlu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayTable_Ordinal = 0x746ebf8659ff23b7lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayErr_Ordinal = 0x6d1c6002c51bb967lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayFieldsErr_Ordinal = 0x2182a49480e5bd2blu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayUnionErr_Ordinal = 0x453af745d38b20calu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictTwoWayTableErr_Ordinal = 0x4c26c7ab89cb68d8lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWay_Ordinal = 0x4a5bb3397008b7clu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayFields_Ordinal = 0x3b13f82f44813a32lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayUnion_Ordinal = 0x44301e4e8d514fb6lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayTable_Ordinal = 0x7f492934b6c76187lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayErr_Ordinal = 0x61240f878cc37c07lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Ordinal = 0xf2b9611a9089b05lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Ordinal = 0x2172940a75f107d7lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayTableErr_Ordinal = 0x6d8aab48e1693bf2lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictEvent_Ordinal = 0x9842669255c4fc1lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictEventFields_Ordinal = 0x7b75ae46520ee732lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictEventUnion_Ordinal = 0x3663b5197598cbdalu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictEventTable_Ordinal = 0x25a10039a9f96910lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEvent_Ordinal = 0x61bb1fab7d767866lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEventFields_Ordinal = 0x3226dff9b0c1d801lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEventUnion_Ordinal = 0x22afd161ca71e467lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEventTable_Ordinal = 0x4f72dd46888b89e0lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;} // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| #ifdef __Fuchsia__ |
| |
| using UnknownInteractionsAjarProtocolPtr = ::fidl::InterfacePtr<UnknownInteractionsAjarProtocol>; |
| class UnknownInteractionsAjarProtocol_Proxy; |
| class UnknownInteractionsAjarProtocol_Stub; |
| class UnknownInteractionsAjarProtocol_EventSender; |
| class UnknownInteractionsAjarProtocol_Sync; |
| using UnknownInteractionsAjarProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<UnknownInteractionsAjarProtocol>; |
| class UnknownInteractionsAjarProtocol_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictOneWay_Ordinal = 0xd4663d6b2b5048blu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleOneWay_Ordinal = 0x2275b8171ae4834flu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWay_Ordinal = 0x50e66d328336038lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayFields_Ordinal = 0x1947e36d61e4493alu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayUnion_Ordinal = 0x5177371967e0e6d1lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayTable_Ordinal = 0x6f8f9343b34e2ed4lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayErr_Ordinal = 0x5b47637577c69006lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Ordinal = 0x844ff7bb3f186d9lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Ordinal = 0x2cbfd5a859d4ac95lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Ordinal = 0x30c9e1b3da57dc37lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEvent_Ordinal = 0x6022ae999e9dc2b0lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEventFields_Ordinal = 0x510586752445c769lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEventUnion_Ordinal = 0x57794b4cc91f816flu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEventTable_Ordinal = 0x92639249201f89dlu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEvent_Ordinal = 0x11c9ba570ce71df3lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEventFields_Ordinal = 0x3ba8fd32bf87d862lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEventUnion_Ordinal = 0x7c3823f47ce0fcadlu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEventTable_Ordinal = 0x9ca944d1d6436b0lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod;} // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| #ifdef __Fuchsia__ |
| |
| using UnknownInteractionsClosedProtocolPtr = ::fidl::InterfacePtr<UnknownInteractionsClosedProtocol>; |
| class UnknownInteractionsClosedProtocol_Proxy; |
| class UnknownInteractionsClosedProtocol_Stub; |
| class UnknownInteractionsClosedProtocol_EventSender; |
| class UnknownInteractionsClosedProtocol_Sync; |
| using UnknownInteractionsClosedProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<UnknownInteractionsClosedProtocol>; |
| class UnknownInteractionsClosedProtocol_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictOneWay_Ordinal = 0x59282385962da24lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictOneWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWay_Ordinal = 0x5eda305d6b22f1f7lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayFields_Ordinal = 0x1323afa3e0541253lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayUnion_Ordinal = 0x68b32554eb0f6fa7lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayTable_Ordinal = 0x6e4a94d44b69e785lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayErr_Ordinal = 0x4fa35d5433db4d3alu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Ordinal = 0xb22aebf23bb58fdlu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Ordinal = 0xcd65d4d29a43c80lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Ordinal = 0x117dde20b92f7b90lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayTableErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEvent_Ordinal = 0xa8ee6ee302f693blu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEventFields_Ordinal = 0x5d7c57b62e9c3a74lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEventFields_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEventUnion_Ordinal = 0x3b8475deeb4a9d64lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEventUnion_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEventTable_Ordinal = 0x27da43fc85a7f5belu; |
| |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEventTable_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;} // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsProtocol { |
| public: |
| using Proxy_ = ::test::unknowninteractions::UnknownInteractionsProtocol_Proxy; |
| using Stub_ = ::test::unknowninteractions::UnknownInteractionsProtocol_Stub; |
| using EventSender_ = ::test::unknowninteractions::UnknownInteractionsProtocol_EventSender; |
| using Sync_ = ::test::unknowninteractions::UnknownInteractionsProtocol_Sync; |
| virtual ~UnknownInteractionsProtocol(); |
| |
| virtual void StrictOneWay() = 0; |
| |
| virtual void FlexibleOneWay() = 0; |
| using StrictTwoWayCallback = |
| fit::function<void()>; |
| |
| virtual void StrictTwoWay(StrictTwoWayCallback callback) = 0; |
| using StrictTwoWayFieldsCallback = |
| fit::function<void(int32_t)>; |
| |
| virtual void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) = 0; |
| using StrictTwoWayUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse)>; |
| |
| virtual void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) = 0; |
| using StrictTwoWayTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse)>; |
| |
| virtual void StrictTwoWayTable(StrictTwoWayTableCallback callback) = 0; |
| using StrictTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result)>; |
| |
| virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0; |
| using StrictTwoWayFieldsErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result)>; |
| |
| virtual void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) = 0; |
| using StrictTwoWayUnionErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result)>; |
| |
| virtual void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) = 0; |
| using StrictTwoWayTableErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result)>; |
| |
| virtual void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) = 0; |
| using FlexibleTwoWayCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result)>; |
| |
| virtual void FlexibleTwoWay(FlexibleTwoWayCallback callback) = 0; |
| using FlexibleTwoWayFieldsCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result)>; |
| |
| virtual void FlexibleTwoWayFields(FlexibleTwoWayFieldsCallback callback) = 0; |
| using FlexibleTwoWayUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result)>; |
| |
| virtual void FlexibleTwoWayUnion(FlexibleTwoWayUnionCallback callback) = 0; |
| using FlexibleTwoWayTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result)>; |
| |
| virtual void FlexibleTwoWayTable(FlexibleTwoWayTableCallback callback) = 0; |
| using FlexibleTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result)>; |
| |
| virtual void FlexibleTwoWayErr(FlexibleTwoWayErrCallback callback) = 0; |
| using FlexibleTwoWayFieldsErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result)>; |
| |
| virtual void FlexibleTwoWayFieldsErr(FlexibleTwoWayFieldsErrCallback callback) = 0; |
| using FlexibleTwoWayUnionErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result)>; |
| |
| virtual void FlexibleTwoWayUnionErr(FlexibleTwoWayUnionErrCallback callback) = 0; |
| using FlexibleTwoWayTableErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result)>; |
| |
| virtual void FlexibleTwoWayTableErr(FlexibleTwoWayTableErrCallback callback) = 0; |
| using StrictEventCallback = |
| fit::function<void()>; |
| using StrictEventFieldsCallback = |
| fit::function<void(int32_t)>; |
| using StrictEventUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest)>; |
| using StrictEventTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest)>; |
| using FlexibleEventCallback = |
| fit::function<void()>; |
| using FlexibleEventFieldsCallback = |
| fit::function<void(int32_t)>; |
| using FlexibleEventUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest)>; |
| using FlexibleEventTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest)>; |
| |
| protected: |
| // Allow the stub to access the handle_unknown_method method. |
| friend class UnknownInteractionsProtocol_Stub; |
| |
| virtual void handle_unknown_method(uint64_t ordinal, bool method_has_response) = 0; |
| |
| }; |
| |
| class UnknownInteractionsProtocol_RequestDecoder { |
| public: |
| UnknownInteractionsProtocol_RequestDecoder() = default; |
| virtual ~UnknownInteractionsProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void StrictOneWay() = 0; |
| virtual void FlexibleOneWay() = 0; |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayFields() = 0; |
| virtual void StrictTwoWayUnion() = 0; |
| virtual void StrictTwoWayTable() = 0; |
| virtual void StrictTwoWayErr() = 0; |
| virtual void StrictTwoWayFieldsErr() = 0; |
| virtual void StrictTwoWayUnionErr() = 0; |
| virtual void StrictTwoWayTableErr() = 0; |
| virtual void FlexibleTwoWay() = 0; |
| virtual void FlexibleTwoWayFields() = 0; |
| virtual void FlexibleTwoWayUnion() = 0; |
| virtual void FlexibleTwoWayTable() = 0; |
| virtual void FlexibleTwoWayErr() = 0; |
| virtual void FlexibleTwoWayFieldsErr() = 0; |
| virtual void FlexibleTwoWayUnionErr() = 0; |
| virtual void FlexibleTwoWayTableErr() = 0; |
| }; |
| |
| class UnknownInteractionsProtocol_ResponseDecoder { |
| public: |
| UnknownInteractionsProtocol_ResponseDecoder() = default; |
| virtual ~UnknownInteractionsProtocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayFields(int32_t some_field) = 0; |
| virtual void StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse UnknownInteractionsProtocolStrictTwoWayUnionResponse) = 0; |
| virtual void StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse UnknownInteractionsProtocolStrictTwoWayTableResponse) = 0; |
| virtual void StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result UnknownInteractionsProtocol_StrictTwoWayErr_Result) = 0; |
| virtual void StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result) = 0; |
| virtual void StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result) = 0; |
| virtual void StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result UnknownInteractionsProtocol_StrictTwoWayTableErr_Result) = 0; |
| virtual void FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result UnknownInteractionsProtocol_FlexibleTwoWay_Result) = 0; |
| virtual void FlexibleTwoWayFields(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result UnknownInteractionsProtocol_FlexibleTwoWayFields_Result) = 0; |
| virtual void FlexibleTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result) = 0; |
| virtual void FlexibleTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result UnknownInteractionsProtocol_FlexibleTwoWayTable_Result) = 0; |
| virtual void FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result UnknownInteractionsProtocol_FlexibleTwoWayErr_Result) = 0; |
| virtual void FlexibleTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result) = 0; |
| virtual void FlexibleTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result) = 0; |
| virtual void FlexibleTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result) = 0; |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventFields(int32_t some_field) = 0; |
| virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest UnknownInteractionsProtocolStrictEventUnionRequest) = 0; |
| virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest UnknownInteractionsProtocolStrictEventTableRequest) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventFields(int32_t some_field) = 0; |
| virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest UnknownInteractionsProtocolFlexibleEventUnionRequest) = 0; |
| virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest UnknownInteractionsProtocolFlexibleEventTableRequest) = 0; |
| }; |
| |
| class UnknownInteractionsProtocol_EventSender { |
| public: |
| virtual ~UnknownInteractionsProtocol_EventSender(); |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventFields(int32_t some_field) = 0; |
| virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest UnknownInteractionsProtocolStrictEventUnionRequest) = 0; |
| virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest UnknownInteractionsProtocolStrictEventTableRequest) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventFields(int32_t some_field) = 0; |
| virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest UnknownInteractionsProtocolFlexibleEventUnionRequest) = 0; |
| virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest UnknownInteractionsProtocolFlexibleEventTableRequest) = 0; |
| }; |
| |
| class UnknownInteractionsProtocol_Sync { |
| public: |
| using Proxy_ = ::test::unknowninteractions::UnknownInteractionsProtocol_SyncProxy; |
| virtual ~UnknownInteractionsProtocol_Sync(); |
| virtual zx_status_t StrictOneWay() = 0; |
| virtual zx_status_t FlexibleOneWay() = 0; |
| virtual zx_status_t StrictTwoWay() = 0; |
| virtual zx_status_t StrictTwoWayFields(int32_t* out_some_field) = 0; |
| virtual zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsProtocolStrictTwoWayUnionResponse) = 0; |
| virtual zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse* out_UnknownInteractionsProtocolStrictTwoWayTableResponse) = 0; |
| virtual zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayTableErr_Result) = 0; |
| virtual zx_status_t FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* out_UnknownInteractionsProtocol_FlexibleTwoWay_Result) = 0; |
| virtual zx_status_t FlexibleTwoWayFields(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFields_Result) = 0; |
| virtual zx_status_t FlexibleTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result) = 0; |
| virtual zx_status_t FlexibleTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTable_Result) = 0; |
| virtual zx_status_t FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayErr_Result) = 0; |
| virtual zx_status_t FlexibleTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result) = 0; |
| virtual zx_status_t FlexibleTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result) = 0; |
| virtual zx_status_t FlexibleTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result) = 0; |
| }; |
| |
| class UnknownInteractionsProtocol_Proxy final : public ::fidl::internal::Proxy, public UnknownInteractionsProtocol { |
| public: |
| explicit UnknownInteractionsProtocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~UnknownInteractionsProtocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictOneWay |
| void StrictOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleOneWay |
| void FlexibleOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWay |
| void StrictTwoWay(StrictTwoWayCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFields |
| void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnion |
| void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTable |
| void StrictTwoWayTable(StrictTwoWayTableCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayErr |
| void StrictTwoWayErr(StrictTwoWayErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFieldsErr |
| void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnionErr |
| void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTableErr |
| void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWay |
| void FlexibleTwoWay(FlexibleTwoWayCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFields |
| void FlexibleTwoWayFields(FlexibleTwoWayFieldsCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnion |
| void FlexibleTwoWayUnion(FlexibleTwoWayUnionCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTable |
| void FlexibleTwoWayTable(FlexibleTwoWayTableCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayErr |
| void FlexibleTwoWayErr(FlexibleTwoWayErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFieldsErr |
| void FlexibleTwoWayFieldsErr(FlexibleTwoWayFieldsErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnionErr |
| void FlexibleTwoWayUnionErr(FlexibleTwoWayUnionErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTableErr |
| void FlexibleTwoWayTableErr(FlexibleTwoWayTableErrCallback callback) override; |
| StrictEventCallback StrictEvent; |
| StrictEventFieldsCallback StrictEventFields; |
| StrictEventUnionCallback StrictEventUnion; |
| StrictEventTableCallback StrictEventTable; |
| FlexibleEventCallback FlexibleEvent; |
| FlexibleEventFieldsCallback FlexibleEventFields; |
| FlexibleEventUnionCallback FlexibleEventUnion; |
| FlexibleEventTableCallback FlexibleEventTable; |
| |
| fit::function<void(uint64_t)> handle_unknown_event; |
| |
| protected: |
| void handle_unknown_method(uint64_t ordinal, bool method_has_response) override { |
| // This method is only provided to satisfy the base interface. It's |
| // protected and should never be called by generated code on the client |
| // side, so it should never be called. |
| ZX_PANIC("Unreachable: UnknownInteractionsProtocol_Proxy::handle_unknown_method should not be callable"); |
| } |
| |
| |
| |
| private: |
| UnknownInteractionsProtocol_Proxy(const ::test::unknowninteractions::UnknownInteractionsProtocol_Proxy&) = delete; |
| UnknownInteractionsProtocol_Proxy& operator=(const ::test::unknowninteractions::UnknownInteractionsProtocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class UnknownInteractionsProtocol_Stub final : public ::fidl::internal::Stub, public ::test::unknowninteractions::UnknownInteractionsProtocol_EventSender { |
| public: |
| typedef class ::test::unknowninteractions::UnknownInteractionsProtocol UnknownInteractionsProtocol_clazz; |
| explicit UnknownInteractionsProtocol_Stub(::test::unknowninteractions::UnknownInteractionsProtocol_Stub::UnknownInteractionsProtocol_clazz* impl); |
| ~UnknownInteractionsProtocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| void StrictEvent() override; |
| void StrictEventFields(int32_t some_field) override; |
| void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventUnionRequest UnknownInteractionsProtocolStrictEventUnionRequest) override; |
| void StrictEventTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictEventTableRequest UnknownInteractionsProtocolStrictEventTableRequest) override; |
| void FlexibleEvent() override; |
| void FlexibleEventFields(int32_t some_field) override; |
| void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventUnionRequest UnknownInteractionsProtocolFlexibleEventUnionRequest) override; |
| void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventTableRequest UnknownInteractionsProtocolFlexibleEventTableRequest) override; |
| |
| private: |
| ::test::unknowninteractions::UnknownInteractionsProtocol_Stub::UnknownInteractionsProtocol_clazz* impl_; |
| }; |
| |
| class UnknownInteractionsProtocol_SyncProxy : public ::test::unknowninteractions::UnknownInteractionsProtocol_Sync { |
| public: |
| explicit UnknownInteractionsProtocol_SyncProxy(::zx::channel channel); |
| ~UnknownInteractionsProtocol_SyncProxy() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictOneWay |
| zx_status_t StrictOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleOneWay |
| zx_status_t FlexibleOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWay |
| zx_status_t StrictTwoWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFields |
| zx_status_t StrictTwoWayFields(int32_t* out_some_field) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnion |
| zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsProtocolStrictTwoWayUnionResponse) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTable |
| zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayTableResponse* out_UnknownInteractionsProtocolStrictTwoWayTableResponse) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayErr |
| zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayFieldsErr |
| zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayFieldsErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayUnionErr |
| zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayUnionErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.StrictTwoWayTableErr |
| zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsProtocol_StrictTwoWayTableErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWay |
| zx_status_t FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* out_UnknownInteractionsProtocol_FlexibleTwoWay_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFields |
| zx_status_t FlexibleTwoWayFields(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFields_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFields_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnion |
| zx_status_t FlexibleTwoWayUnion(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnion_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTable |
| zx_status_t FlexibleTwoWayTable(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTable_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTable_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayErr |
| zx_status_t FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayFieldsErr |
| zx_status_t FlexibleTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayFieldsErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayUnionErr |
| zx_status_t FlexibleTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayUnionErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayTableErr |
| zx_status_t FlexibleTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result* out_UnknownInteractionsProtocol_FlexibleTwoWayTableErr_Result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<UnknownInteractionsProtocol>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsAjarProtocol { |
| public: |
| using Proxy_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Proxy; |
| using Stub_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Stub; |
| using EventSender_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_EventSender; |
| using Sync_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Sync; |
| virtual ~UnknownInteractionsAjarProtocol(); |
| |
| virtual void StrictOneWay() = 0; |
| |
| virtual void FlexibleOneWay() = 0; |
| using StrictTwoWayCallback = |
| fit::function<void()>; |
| |
| virtual void StrictTwoWay(StrictTwoWayCallback callback) = 0; |
| using StrictTwoWayFieldsCallback = |
| fit::function<void(int32_t)>; |
| |
| virtual void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) = 0; |
| using StrictTwoWayUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse)>; |
| |
| virtual void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) = 0; |
| using StrictTwoWayTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse)>; |
| |
| virtual void StrictTwoWayTable(StrictTwoWayTableCallback callback) = 0; |
| using StrictTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result)>; |
| |
| virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0; |
| using StrictTwoWayFieldsErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result)>; |
| |
| virtual void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) = 0; |
| using StrictTwoWayUnionErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result)>; |
| |
| virtual void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) = 0; |
| using StrictTwoWayTableErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result)>; |
| |
| virtual void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) = 0; |
| using StrictEventCallback = |
| fit::function<void()>; |
| using StrictEventFieldsCallback = |
| fit::function<void(int32_t)>; |
| using StrictEventUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest)>; |
| using StrictEventTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest)>; |
| using FlexibleEventCallback = |
| fit::function<void()>; |
| using FlexibleEventFieldsCallback = |
| fit::function<void(int32_t)>; |
| using FlexibleEventUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest)>; |
| using FlexibleEventTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest)>; |
| |
| protected: |
| // Allow the stub to access the handle_unknown_method method. |
| friend class UnknownInteractionsAjarProtocol_Stub; |
| |
| virtual void handle_unknown_method(uint64_t ordinal) = 0; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_RequestDecoder { |
| public: |
| UnknownInteractionsAjarProtocol_RequestDecoder() = default; |
| virtual ~UnknownInteractionsAjarProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void StrictOneWay() = 0; |
| virtual void FlexibleOneWay() = 0; |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayFields() = 0; |
| virtual void StrictTwoWayUnion() = 0; |
| virtual void StrictTwoWayTable() = 0; |
| virtual void StrictTwoWayErr() = 0; |
| virtual void StrictTwoWayFieldsErr() = 0; |
| virtual void StrictTwoWayUnionErr() = 0; |
| virtual void StrictTwoWayTableErr() = 0; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_ResponseDecoder { |
| public: |
| UnknownInteractionsAjarProtocol_ResponseDecoder() = default; |
| virtual ~UnknownInteractionsAjarProtocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayFields(int32_t some_field) = 0; |
| virtual void StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) = 0; |
| virtual void StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) = 0; |
| virtual void StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result) = 0; |
| virtual void StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result) = 0; |
| virtual void StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result) = 0; |
| virtual void StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result) = 0; |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventFields(int32_t some_field) = 0; |
| virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest UnknownInteractionsAjarProtocolStrictEventUnionRequest) = 0; |
| virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest UnknownInteractionsAjarProtocolStrictEventTableRequest) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventFields(int32_t some_field) = 0; |
| virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) = 0; |
| virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest UnknownInteractionsAjarProtocolFlexibleEventTableRequest) = 0; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_EventSender { |
| public: |
| virtual ~UnknownInteractionsAjarProtocol_EventSender(); |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventFields(int32_t some_field) = 0; |
| virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest UnknownInteractionsAjarProtocolStrictEventUnionRequest) = 0; |
| virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest UnknownInteractionsAjarProtocolStrictEventTableRequest) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventFields(int32_t some_field) = 0; |
| virtual void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) = 0; |
| virtual void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest UnknownInteractionsAjarProtocolFlexibleEventTableRequest) = 0; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_Sync { |
| public: |
| using Proxy_ = ::test::unknowninteractions::UnknownInteractionsAjarProtocol_SyncProxy; |
| virtual ~UnknownInteractionsAjarProtocol_Sync(); |
| virtual zx_status_t StrictOneWay() = 0; |
| virtual zx_status_t FlexibleOneWay() = 0; |
| virtual zx_status_t StrictTwoWay() = 0; |
| virtual zx_status_t StrictTwoWayFields(int32_t* out_some_field) = 0; |
| virtual zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) = 0; |
| virtual zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) = 0; |
| virtual zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result) = 0; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_Proxy final : public ::fidl::internal::Proxy, public UnknownInteractionsAjarProtocol { |
| public: |
| explicit UnknownInteractionsAjarProtocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~UnknownInteractionsAjarProtocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictOneWay |
| void StrictOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.FlexibleOneWay |
| void FlexibleOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWay |
| void StrictTwoWay(StrictTwoWayCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFields |
| void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnion |
| void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTable |
| void StrictTwoWayTable(StrictTwoWayTableCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayErr |
| void StrictTwoWayErr(StrictTwoWayErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFieldsErr |
| void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnionErr |
| void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTableErr |
| void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) override; |
| StrictEventCallback StrictEvent; |
| StrictEventFieldsCallback StrictEventFields; |
| StrictEventUnionCallback StrictEventUnion; |
| StrictEventTableCallback StrictEventTable; |
| FlexibleEventCallback FlexibleEvent; |
| FlexibleEventFieldsCallback FlexibleEventFields; |
| FlexibleEventUnionCallback FlexibleEventUnion; |
| FlexibleEventTableCallback FlexibleEventTable; |
| |
| fit::function<void(uint64_t)> handle_unknown_event; |
| |
| protected: |
| void handle_unknown_method(uint64_t ordinal) override { |
| // This method is only provided to satisfy the base interface. It's |
| // protected and should never be called by generated code on the client |
| // side, so it should never be called. |
| ZX_PANIC("Unreachable: UnknownInteractionsAjarProtocol_Proxy::handle_unknown_method should not be callable"); |
| } |
| |
| |
| private: |
| UnknownInteractionsAjarProtocol_Proxy(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Proxy&) = delete; |
| UnknownInteractionsAjarProtocol_Proxy& operator=(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_Stub final : public ::fidl::internal::Stub, public ::test::unknowninteractions::UnknownInteractionsAjarProtocol_EventSender { |
| public: |
| typedef class ::test::unknowninteractions::UnknownInteractionsAjarProtocol UnknownInteractionsAjarProtocol_clazz; |
| explicit UnknownInteractionsAjarProtocol_Stub(::test::unknowninteractions::UnknownInteractionsAjarProtocol_Stub::UnknownInteractionsAjarProtocol_clazz* impl); |
| ~UnknownInteractionsAjarProtocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| void StrictEvent() override; |
| void StrictEventFields(int32_t some_field) override; |
| void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventUnionRequest UnknownInteractionsAjarProtocolStrictEventUnionRequest) override; |
| void StrictEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventTableRequest UnknownInteractionsAjarProtocolStrictEventTableRequest) override; |
| void FlexibleEvent() override; |
| void FlexibleEventFields(int32_t some_field) override; |
| void FlexibleEventUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventUnionRequest UnknownInteractionsAjarProtocolFlexibleEventUnionRequest) override; |
| void FlexibleEventTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventTableRequest UnknownInteractionsAjarProtocolFlexibleEventTableRequest) override; |
| |
| private: |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Stub::UnknownInteractionsAjarProtocol_clazz* impl_; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_SyncProxy : public ::test::unknowninteractions::UnknownInteractionsAjarProtocol_Sync { |
| public: |
| explicit UnknownInteractionsAjarProtocol_SyncProxy(::zx::channel channel); |
| ~UnknownInteractionsAjarProtocol_SyncProxy() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictOneWay |
| zx_status_t StrictOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.FlexibleOneWay |
| zx_status_t FlexibleOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWay |
| zx_status_t StrictTwoWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFields |
| zx_status_t StrictTwoWayFields(int32_t* out_some_field) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnion |
| zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayUnionResponse) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTable |
| zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayTableResponse* out_UnknownInteractionsAjarProtocolStrictTwoWayTableResponse) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayErr |
| zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayFieldsErr |
| zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayFieldsErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayUnionErr |
| zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayUnionErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsAjarProtocol.StrictTwoWayTableErr |
| zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsAjarProtocol_StrictTwoWayTableErr_Result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<UnknownInteractionsAjarProtocol>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsClosedProtocol { |
| public: |
| using Proxy_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Proxy; |
| using Stub_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Stub; |
| using EventSender_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_EventSender; |
| using Sync_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Sync; |
| virtual ~UnknownInteractionsClosedProtocol(); |
| |
| virtual void StrictOneWay() = 0; |
| using StrictTwoWayCallback = |
| fit::function<void()>; |
| |
| virtual void StrictTwoWay(StrictTwoWayCallback callback) = 0; |
| using StrictTwoWayFieldsCallback = |
| fit::function<void(int32_t)>; |
| |
| virtual void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) = 0; |
| using StrictTwoWayUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse)>; |
| |
| virtual void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) = 0; |
| using StrictTwoWayTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse)>; |
| |
| virtual void StrictTwoWayTable(StrictTwoWayTableCallback callback) = 0; |
| using StrictTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result)>; |
| |
| virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0; |
| using StrictTwoWayFieldsErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result)>; |
| |
| virtual void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) = 0; |
| using StrictTwoWayUnionErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result)>; |
| |
| virtual void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) = 0; |
| using StrictTwoWayTableErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result)>; |
| |
| virtual void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) = 0; |
| using StrictEventCallback = |
| fit::function<void()>; |
| using StrictEventFieldsCallback = |
| fit::function<void(int32_t)>; |
| using StrictEventUnionCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest)>; |
| using StrictEventTableCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest)>; |
| |
| |
| }; |
| |
| class UnknownInteractionsClosedProtocol_RequestDecoder { |
| public: |
| UnknownInteractionsClosedProtocol_RequestDecoder() = default; |
| virtual ~UnknownInteractionsClosedProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void StrictOneWay() = 0; |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayFields() = 0; |
| virtual void StrictTwoWayUnion() = 0; |
| virtual void StrictTwoWayTable() = 0; |
| virtual void StrictTwoWayErr() = 0; |
| virtual void StrictTwoWayFieldsErr() = 0; |
| virtual void StrictTwoWayUnionErr() = 0; |
| virtual void StrictTwoWayTableErr() = 0; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_ResponseDecoder { |
| public: |
| UnknownInteractionsClosedProtocol_ResponseDecoder() = default; |
| virtual ~UnknownInteractionsClosedProtocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayFields(int32_t some_field) = 0; |
| virtual void StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) = 0; |
| virtual void StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) = 0; |
| virtual void StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result) = 0; |
| virtual void StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result) = 0; |
| virtual void StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result) = 0; |
| virtual void StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result) = 0; |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventFields(int32_t some_field) = 0; |
| virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest UnknownInteractionsClosedProtocolStrictEventUnionRequest) = 0; |
| virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest UnknownInteractionsClosedProtocolStrictEventTableRequest) = 0; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_EventSender { |
| public: |
| virtual ~UnknownInteractionsClosedProtocol_EventSender(); |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventFields(int32_t some_field) = 0; |
| virtual void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest UnknownInteractionsClosedProtocolStrictEventUnionRequest) = 0; |
| virtual void StrictEventTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest UnknownInteractionsClosedProtocolStrictEventTableRequest) = 0; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_Sync { |
| public: |
| using Proxy_ = ::test::unknowninteractions::UnknownInteractionsClosedProtocol_SyncProxy; |
| virtual ~UnknownInteractionsClosedProtocol_Sync(); |
| virtual zx_status_t StrictOneWay() = 0; |
| virtual zx_status_t StrictTwoWay() = 0; |
| virtual zx_status_t StrictTwoWayFields(int32_t* out_some_field) = 0; |
| virtual zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) = 0; |
| virtual zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) = 0; |
| virtual zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result) = 0; |
| virtual zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result) = 0; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_Proxy final : public ::fidl::internal::Proxy, public UnknownInteractionsClosedProtocol { |
| public: |
| explicit UnknownInteractionsClosedProtocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~UnknownInteractionsClosedProtocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictOneWay |
| void StrictOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWay |
| void StrictTwoWay(StrictTwoWayCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFields |
| void StrictTwoWayFields(StrictTwoWayFieldsCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnion |
| void StrictTwoWayUnion(StrictTwoWayUnionCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTable |
| void StrictTwoWayTable(StrictTwoWayTableCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayErr |
| void StrictTwoWayErr(StrictTwoWayErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFieldsErr |
| void StrictTwoWayFieldsErr(StrictTwoWayFieldsErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnionErr |
| void StrictTwoWayUnionErr(StrictTwoWayUnionErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTableErr |
| void StrictTwoWayTableErr(StrictTwoWayTableErrCallback callback) override; |
| StrictEventCallback StrictEvent; |
| StrictEventFieldsCallback StrictEventFields; |
| StrictEventUnionCallback StrictEventUnion; |
| StrictEventTableCallback StrictEventTable; |
| |
| |
| |
| |
| private: |
| UnknownInteractionsClosedProtocol_Proxy(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Proxy&) = delete; |
| UnknownInteractionsClosedProtocol_Proxy& operator=(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_Stub final : public ::fidl::internal::Stub, public ::test::unknowninteractions::UnknownInteractionsClosedProtocol_EventSender { |
| public: |
| typedef class ::test::unknowninteractions::UnknownInteractionsClosedProtocol UnknownInteractionsClosedProtocol_clazz; |
| explicit UnknownInteractionsClosedProtocol_Stub(::test::unknowninteractions::UnknownInteractionsClosedProtocol_Stub::UnknownInteractionsClosedProtocol_clazz* impl); |
| ~UnknownInteractionsClosedProtocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| void StrictEvent() override; |
| void StrictEventFields(int32_t some_field) override; |
| void StrictEventUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventUnionRequest UnknownInteractionsClosedProtocolStrictEventUnionRequest) override; |
| void StrictEventTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventTableRequest UnknownInteractionsClosedProtocolStrictEventTableRequest) override; |
| |
| private: |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Stub::UnknownInteractionsClosedProtocol_clazz* impl_; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_SyncProxy : public ::test::unknowninteractions::UnknownInteractionsClosedProtocol_Sync { |
| public: |
| explicit UnknownInteractionsClosedProtocol_SyncProxy(::zx::channel channel); |
| ~UnknownInteractionsClosedProtocol_SyncProxy() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictOneWay |
| zx_status_t StrictOneWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWay |
| zx_status_t StrictTwoWay() override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFields |
| zx_status_t StrictTwoWayFields(int32_t* out_some_field) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnion |
| zx_status_t StrictTwoWayUnion(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayUnionResponse) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTable |
| zx_status_t StrictTwoWayTable(::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayTableResponse* out_UnknownInteractionsClosedProtocolStrictTwoWayTableResponse) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayErr |
| zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayFieldsErr |
| zx_status_t StrictTwoWayFieldsErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayFieldsErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayUnionErr |
| zx_status_t StrictTwoWayUnionErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayUnionErr_Result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsClosedProtocol.StrictTwoWayTableErr |
| zx_status_t StrictTwoWayTableErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result* out_UnknownInteractionsClosedProtocol_StrictTwoWayTableErr_Result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<UnknownInteractionsClosedProtocol>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| } // namespace unknowninteractions |
| } // namespace test |
| |
| |