| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include "lib/fidl/cpp/internal/header.h" |
| |
| namespace test { |
| namespace unknowninteractions { |
| |
| // |
| // Domain objects declarations |
| // |
| |
| class UnknownInteractionsProtocol_StrictTwoWayErr_Response; |
| |
| class UnknownInteractionsProtocol_StrictTwoWayErr_Result; |
| |
| class UnknownInteractionsProtocolStrictTwoWayErrTopResponse; |
| |
| class UnknownInteractionsProtocol_StrictEventErr_Response; |
| |
| class UnknownInteractionsProtocol_StrictEventErr_Result; |
| |
| class UnknownInteractionsProtocolStrictEventErrRequest; |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWay_Response; |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWay_Result; |
| |
| class UnknownInteractionsProtocolFlexibleTwoWayTopResponse; |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayErr_Response; |
| |
| class UnknownInteractionsProtocol_FlexibleTwoWayErr_Result; |
| |
| class UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse; |
| |
| class UnknownInteractionsProtocol_FlexibleEventErr_Response; |
| |
| class UnknownInteractionsProtocol_FlexibleEventErr_Result; |
| |
| class UnknownInteractionsProtocolFlexibleEventErrRequest; |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsProtocol; |
| using UnknownInteractionsProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsProtocol>; |
| #endif // __Fuchsia__ |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Response; |
| |
| class UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result; |
| |
| class UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse; |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Response; |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result; |
| |
| class UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse; |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response; |
| |
| class UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result; |
| |
| class UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse; |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Response; |
| |
| class UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result; |
| |
| class UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse; |
| |
| class UnknownInteractionsClosedProtocol_StrictEventErr_Response; |
| |
| class UnknownInteractionsClosedProtocol_StrictEventErr_Result; |
| |
| class UnknownInteractionsClosedProtocolStrictEventErrRequest; |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsClosedProtocol; |
| using UnknownInteractionsClosedProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsClosedProtocol>; |
| #endif // __Fuchsia__ |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Response; |
| |
| class UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result; |
| |
| class UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse; |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Response; |
| |
| class UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result; |
| |
| class UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse; |
| |
| class UnknownInteractionsAjarProtocol_StrictEventErr_Response; |
| |
| class UnknownInteractionsAjarProtocol_StrictEventErr_Result; |
| |
| class UnknownInteractionsAjarProtocolStrictEventErrRequest; |
| |
| class UnknownInteractionsAjarProtocol_FlexibleEventErr_Response; |
| |
| class UnknownInteractionsAjarProtocol_FlexibleEventErr_Result; |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventErrRequest; |
| |
| #ifdef __Fuchsia__ |
| |
| class UnknownInteractionsAjarProtocol; |
| using UnknownInteractionsAjarProtocolHandle = ::fidl::InterfaceHandle<UnknownInteractionsAjarProtocol>; |
| #endif // __Fuchsia__ |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Response; |
| |
| class UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result; |
| |
| class UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse; |
| |
| 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::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()); |
| } |
| } |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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 UnknownInteractionsProtocolStrictTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolStrictTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictTwoWayErrTopResponse>; |
| |
| class UnknownInteractionsProtocol_StrictEventErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_StrictEventErr_Response() = default; |
| explicit UnknownInteractionsProtocol_StrictEventErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsProtocol_StrictEventErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple(); |
| } |
| |
| uint8_t __reserved = 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_StrictEventErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictEventErr_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_StrictEventErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictEventErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictEventErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictEventErr_Response>; |
| |
| class UnknownInteractionsProtocol_StrictEventErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_StrictEventErr_Result(); |
| ~UnknownInteractionsProtocol_StrictEventErr_Result(); |
| |
| UnknownInteractionsProtocol_StrictEventErr_Result(UnknownInteractionsProtocol_StrictEventErr_Result&&); |
| UnknownInteractionsProtocol_StrictEventErr_Result& operator=(UnknownInteractionsProtocol_StrictEventErr_Result&&); |
| |
| static UnknownInteractionsProtocol_StrictEventErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response&&); |
| static UnknownInteractionsProtocol_StrictEventErr_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_StrictEventErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_StrictEventErr_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_StrictEventErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_StrictEventErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_StrictEventErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_StrictEventErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag Which() const { |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_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_StrictEventErr_Result>; |
| |
| UnknownInteractionsProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| UnknownInteractionsProtocol_StrictEventErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsProtocol_StrictEventErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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_StrictEventErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_StrictEventErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_StrictEventErr_Result>; |
| |
| class UnknownInteractionsProtocolStrictEventErrRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolStrictEventErrRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolStrictEventErrRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolStrictEventErrRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolStrictEventErrRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolStrictEventErrRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolStrictEventErrRequest>; |
| |
| 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 WithTransportErr(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kTransportErr = 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_transport_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kTransportErr; } |
| |
| int32_t& transport_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result::Tag::kTransportErr); |
| return transport_err_; |
| } |
| |
| const int32_t& transport_err() const { |
| ZX_ASSERT(is_transport_err()); |
| return transport_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWay_Result& set_transport_err(int32_t 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>; |
| |
| 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_; |
| int32_t transport_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 UnknownInteractionsProtocolFlexibleTwoWayTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolFlexibleTwoWayTopResponse> New() { return ::std::make_unique<UnknownInteractionsProtocolFlexibleTwoWayTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolFlexibleTwoWayTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolFlexibleTwoWayTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolFlexibleTwoWayTopResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleTwoWayTopResponse>; |
| |
| 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 WithTransportErr(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kTransportErr = 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_transport_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kTransportErr; } |
| |
| int32_t& transport_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result::Tag::kTransportErr); |
| return transport_err_; |
| } |
| |
| const int32_t& transport_err() const { |
| ZX_ASSERT(is_transport_err()); |
| return transport_err_; |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result& set_transport_err(int32_t 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::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()); |
| } |
| } |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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_FlexibleTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Response response_; |
| int32_t err_; |
| int32_t transport_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 UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolFlexibleTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse>; |
| |
| class UnknownInteractionsProtocol_FlexibleEventErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsProtocol_FlexibleEventErr_Response() = default; |
| explicit UnknownInteractionsProtocol_FlexibleEventErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsProtocol_FlexibleEventErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple(); |
| } |
| |
| uint8_t __reserved = 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleEventErr_Response> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleEventErr_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_FlexibleEventErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleEventErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleEventErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleEventErr_Response>; |
| |
| class UnknownInteractionsProtocol_FlexibleEventErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsProtocol_FlexibleEventErr_Result(); |
| ~UnknownInteractionsProtocol_FlexibleEventErr_Result(); |
| |
| UnknownInteractionsProtocol_FlexibleEventErr_Result(UnknownInteractionsProtocol_FlexibleEventErr_Result&&); |
| UnknownInteractionsProtocol_FlexibleEventErr_Result& operator=(UnknownInteractionsProtocol_FlexibleEventErr_Result&&); |
| |
| static UnknownInteractionsProtocol_FlexibleEventErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response&&); |
| static UnknownInteractionsProtocol_FlexibleEventErr_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_FlexibleEventErr_Result> New() { return ::std::make_unique<UnknownInteractionsProtocol_FlexibleEventErr_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_FlexibleEventErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsProtocol_FlexibleEventErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsProtocol_FlexibleEventErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsProtocol_FlexibleEventErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag Which() const { |
| return ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_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_FlexibleEventErr_Result>; |
| |
| UnknownInteractionsProtocol_FlexibleEventErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| UnknownInteractionsProtocol_FlexibleEventErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsProtocol_FlexibleEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsProtocol_FlexibleEventErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsProtocol_FlexibleEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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_FlexibleEventErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsProtocol_FlexibleEventErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsProtocol_FlexibleEventErr_Result>; |
| |
| class UnknownInteractionsProtocolFlexibleEventErrRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventErrRequest> New() { return ::std::make_unique<UnknownInteractionsProtocolFlexibleEventErrRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsProtocolFlexibleEventErrRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsProtocolFlexibleEventErrRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsProtocolFlexibleEventErrRequestPtr = ::std::unique_ptr<UnknownInteractionsProtocolFlexibleEventErrRequest>; |
| |
| #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 StrictTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWay(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayErrTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleTwoWayTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleTwoWayErrTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolStrictEventErrRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventErrRequestTable; |
| |
| } // namespace _internal |
| class UnknownInteractionsProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsProtocolStrictTwoWayErrTopResponseTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWay(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsProtocolFlexibleTwoWayTopResponseTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsProtocolFlexibleTwoWayErrTopResponseTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsProtocolStrictEventErrRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEvent(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsProtocolFlexibleEventErrRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| #endif // __Fuchsia__ |
| |
| 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::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()); |
| } |
| } |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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 UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse>; |
| |
| 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 WithTransportErr(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kTransportErr = 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_transport_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kTransportErr; } |
| |
| int32_t& transport_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result::Tag::kTransportErr); |
| return transport_err_; |
| } |
| |
| const int32_t& transport_err() const { |
| ZX_ASSERT(is_transport_err()); |
| return transport_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result& set_transport_err(int32_t 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>; |
| |
| 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_; |
| int32_t transport_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 UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse> New() { return ::std::make_unique<UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse>; |
| |
| 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 WithTransportErr(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| kTransportErr = 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_transport_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kTransportErr; } |
| |
| int32_t& transport_err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result::Tag::kTransportErr); |
| return transport_err_; |
| } |
| |
| const int32_t& transport_err() const { |
| ZX_ASSERT(is_transport_err()); |
| return transport_err_; |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result& set_transport_err(int32_t 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::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()); |
| } |
| } |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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_FlexibleTwoWayErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Response response_; |
| int32_t err_; |
| int32_t transport_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 UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse>; |
| |
| 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::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()); |
| } |
| } |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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 UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse>; |
| |
| class UnknownInteractionsClosedProtocol_StrictEventErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsClosedProtocol_StrictEventErr_Response() = default; |
| explicit UnknownInteractionsClosedProtocol_StrictEventErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsClosedProtocol_StrictEventErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple(); |
| } |
| |
| uint8_t __reserved = 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictEventErr_Response> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictEventErr_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_StrictEventErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictEventErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictEventErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictEventErr_Response>; |
| |
| class UnknownInteractionsClosedProtocol_StrictEventErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result(); |
| ~UnknownInteractionsClosedProtocol_StrictEventErr_Result(); |
| |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result(UnknownInteractionsClosedProtocol_StrictEventErr_Result&&); |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result& operator=(UnknownInteractionsClosedProtocol_StrictEventErr_Result&&); |
| |
| static UnknownInteractionsClosedProtocol_StrictEventErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response&&); |
| static UnknownInteractionsClosedProtocol_StrictEventErr_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_StrictEventErr_Result> New() { return ::std::make_unique<UnknownInteractionsClosedProtocol_StrictEventErr_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_StrictEventErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocol_StrictEventErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag Which() const { |
| return ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_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_StrictEventErr_Result>; |
| |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsClosedProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsClosedProtocol_StrictEventErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsClosedProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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_StrictEventErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsClosedProtocol_StrictEventErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocol_StrictEventErr_Result>; |
| |
| class UnknownInteractionsClosedProtocolStrictEventErrRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventErrRequest> New() { return ::std::make_unique<UnknownInteractionsClosedProtocolStrictEventErrRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedProtocolStrictEventErrRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedProtocolStrictEventErrRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedProtocolStrictEventErrRequestPtr = ::std::unique_ptr<UnknownInteractionsClosedProtocolStrictEventErrRequest>; |
| |
| #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 StrictTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventErrRequestTable; |
| |
| } // namespace _internal |
| class UnknownInteractionsClosedProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponseTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsClosedProtocolStrictEventErrRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| #endif // __Fuchsia__ |
| |
| 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::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()); |
| } |
| } |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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 UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse>; |
| |
| 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::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()); |
| } |
| } |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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 UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse>; |
| |
| class UnknownInteractionsAjarProtocol_StrictEventErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsAjarProtocol_StrictEventErr_Response() = default; |
| explicit UnknownInteractionsAjarProtocol_StrictEventErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsAjarProtocol_StrictEventErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple(); |
| } |
| |
| uint8_t __reserved = 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictEventErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictEventErr_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_StrictEventErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictEventErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictEventErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictEventErr_Response>; |
| |
| class UnknownInteractionsAjarProtocol_StrictEventErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result(); |
| ~UnknownInteractionsAjarProtocol_StrictEventErr_Result(); |
| |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result(UnknownInteractionsAjarProtocol_StrictEventErr_Result&&); |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result& operator=(UnknownInteractionsAjarProtocol_StrictEventErr_Result&&); |
| |
| static UnknownInteractionsAjarProtocol_StrictEventErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response&&); |
| static UnknownInteractionsAjarProtocol_StrictEventErr_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_StrictEventErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_StrictEventErr_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_StrictEventErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_StrictEventErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag Which() const { |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_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_StrictEventErr_Result>; |
| |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsAjarProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsAjarProtocol_StrictEventErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsAjarProtocol_StrictEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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_StrictEventErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_StrictEventErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_StrictEventErr_Result>; |
| |
| class UnknownInteractionsAjarProtocolStrictEventErrRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventErrRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolStrictEventErrRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolStrictEventErrRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolStrictEventErrRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocolStrictEventErrRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolStrictEventErrRequest>; |
| |
| class UnknownInteractionsAjarProtocol_FlexibleEventErr_Response final { |
| public: |
| static const fidl_type_t* FidlType; |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Response() = default; |
| explicit UnknownInteractionsAjarProtocol_FlexibleEventErr_Response(uint8_t v) : __reserved(std::move(v)) {} |
| uint8_t ResultValue_() { return std::move(__reserved); } |
| explicit UnknownInteractionsAjarProtocol_FlexibleEventErr_Response(::std::tuple<> _value_tuple) { |
| } |
| operator ::std::tuple<>() && { |
| return std::make_tuple(); |
| } |
| |
| uint8_t __reserved = 0u; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocol_FlexibleEventErr_Response> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_FlexibleEventErr_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_FlexibleEventErr_Response* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_FlexibleEventErr_Response* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_FlexibleEventErr_ResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_FlexibleEventErr_Response>; |
| |
| class UnknownInteractionsAjarProtocol_FlexibleEventErr_Result final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(); |
| ~UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(); |
| |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(UnknownInteractionsAjarProtocol_FlexibleEventErr_Result&&); |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result& operator=(UnknownInteractionsAjarProtocol_FlexibleEventErr_Result&&); |
| |
| static UnknownInteractionsAjarProtocol_FlexibleEventErr_Result WithResponse(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response&&); |
| static UnknownInteractionsAjarProtocol_FlexibleEventErr_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_FlexibleEventErr_Result> New() { return ::std::make_unique<UnknownInteractionsAjarProtocol_FlexibleEventErr_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_FlexibleEventErr_Result* value, size_t offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocol_FlexibleEventErr_Result* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_response() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag::kResponse; } |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response& response() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag::kResponse); |
| return response_; |
| } |
| |
| const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response& response() const { |
| ZX_ASSERT(is_response()); |
| return response_; |
| } |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result& set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response value); |
| |
| bool is_err() const { return tag_ == ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag::kErr; } |
| |
| int32_t& err() { |
| EnsureStorageInitialized(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag::kErr); |
| return err_; |
| } |
| |
| const int32_t& err() const { |
| ZX_ASSERT(is_err()); |
| return err_; |
| } |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result& set_err(int32_t value); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag Which() const { |
| return ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_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_FlexibleEventErr_Result>; |
| |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(fpromise::result<void, int32_t>&& result) { |
| ZX_ASSERT(!result.is_pending()); |
| if (result.is_ok()) { |
| set_response(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response{}); |
| } else { |
| set_err(result.take_error()); |
| } |
| } |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsAjarProtocol_FlexibleEventErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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_FlexibleEventErr_Result::Tag::Invalid); |
| union { |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response response_; |
| int32_t err_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result* result) { |
| return value.Clone(result); |
| } |
| |
| using UnknownInteractionsAjarProtocol_FlexibleEventErr_ResultPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocol_FlexibleEventErr_Result>; |
| |
| class UnknownInteractionsAjarProtocolFlexibleEventErrRequest final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventErrRequest> New() { return ::std::make_unique<UnknownInteractionsAjarProtocolFlexibleEventErrRequest>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarProtocolFlexibleEventErrRequest* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarProtocolFlexibleEventErrRequest* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarProtocolFlexibleEventErrRequestPtr = ::std::unique_ptr<UnknownInteractionsAjarProtocolFlexibleEventErrRequest>; |
| |
| #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 StrictTwoWayErr(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventErrRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventErrRequestTable; |
| |
| } // namespace _internal |
| class UnknownInteractionsAjarProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWay(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictTwoWayErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponseTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEvent(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage StrictEventErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsAjarProtocolStrictEventErrRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEvent(::fidl::MessageEncoder* _encoder) { |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleEventErr(::fidl::MessageEncoder* _encoder, ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result* result) { |
| fidl_trace(WillHLCPPEncode); |
| |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, result, 0 + sizeof(fidl_message_header_t)); |
| |
| fidl_trace(DidHLCPPEncode, &::test::unknowninteractions::_internal::test_unknowninteractions_UnknownInteractionsAjarProtocolFlexibleEventErrRequestTable, _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| #endif // __Fuchsia__ |
| |
| 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::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()); |
| } |
| } |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::ok_result<void>&& result) |
| : UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::error_result<int32_t>&& result) |
| : UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result(fpromise::result<void, int32_t>(std::move(result))) {} |
| 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 UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result result{}; |
| |
| static inline ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse> New() { return ::std::make_unique<UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse* value, size_t _offset); |
| zx_status_t Clone(UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse& _value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponsePtr = ::std::unique_ptr<UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse>; |
| |
| } // namespace unknowninteractions |
| } // namespace test |
| namespace fidl { |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::UnknownInteractionsProtocolStrictTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response>::value && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_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_StrictEventErr_Result>* value, size_t offset) { |
| fidl_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolStrictEventErrRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::kTransportErr: |
| return ::fidl::Equals(_lhs.transport_err_, _rhs.transport_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::kTransportErr: |
| return ::fidl::Equals(_lhs.transport_err_, _rhs.transport_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response>::value && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_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_FlexibleEventErr_Result>* value, size_t offset) { |
| fidl_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsProtocolFlexibleEventErrRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_StrictTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolStrictTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::kTransportErr: |
| return ::fidl::Equals(_lhs.transport_err_, _rhs.transport_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWay_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::kTransportErr: |
| return ::fidl::Equals(_lhs.transport_err_, _rhs.transport_err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsDriverProtocol_FlexibleTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsDriverProtocolFlexibleTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response>::value && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_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_StrictEventErr_Result>* value, size_t offset) { |
| fidl_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedProtocolStrictEventErrRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocol_StrictTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsClosedDriverProtocolStrictTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response>::value && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_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_StrictEventErr_Result>* value, size_t offset) { |
| fidl_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolStrictEventErrRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response>::value && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Response& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_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_FlexibleEventErr_Result>* value, size_t offset) { |
| fidl_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result); |
| |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag::Invalid): |
| return true; |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag::kResponse: |
| return ::fidl::Equals(_lhs.response_, _rhs.response_); |
| case ::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result::Tag::kErr: |
| return ::fidl::Equals(_lhs.err_, _rhs.err_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarProtocolFlexibleEventErrRequest& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| 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_xunion_t* encoded = _decoder->GetPtr<fidl_xunion_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::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse> |
| : public EncodableCodingTraits<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse, 16> {}; |
| |
| template <> |
| struct HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse> : public std::true_type {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse> : public internal::BoolConstant< |
| !HasPadding<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse>::value && IsMemcpyCompatible<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocol_StrictTwoWayErr_Result>::value> {}; |
| |
| inline zx_status_t Clone(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse& value, |
| ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse* result) { |
| return ::test::unknowninteractions::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse> { |
| bool operator()(const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse& _lhs, const ::test::unknowninteractions::UnknownInteractionsAjarDriverProtocolStrictTwoWayErrTopResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.result, _rhs.result)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| |
| // |
| // 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_StrictTwoWayErr_Ordinal = 0x6d1c6002c51bb967lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWay_Ordinal = 0x4a5bb3397008b7clu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWay_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleTwoWayErr_Ordinal = 0x61240f878cc37c07lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictEvent_Ordinal = 0x9842669255c4fc1lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsProtocol_StrictEventErr_Ordinal = 0x3d956048f723bc6dlu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_StrictEventErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEvent_Ordinal = 0x61bb1fab7d767866lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| constexpr uint64_t kUnknownInteractionsProtocol_FlexibleEventErr_Ordinal = 0x4bda3e6fb22bb5a9lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsProtocol_FlexibleEventErr_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_StrictTwoWayErr_Ordinal = 0x4fa35d5433db4d3alu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEvent_Ordinal = 0xa8ee6ee302f693blu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsClosedProtocol_StrictEventErr_Ordinal = 0x12b105b1430a1201lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsClosedProtocol_StrictEventErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| } // 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_StrictTwoWayErr_Ordinal = 0x5b47637577c69006lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictTwoWayErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEvent_Ordinal = 0x6022ae999e9dc2b0lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_StrictEventErr_Ordinal = 0x715bfcab27f735edlu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_StrictEventErr_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEvent_Ordinal = 0x11c9ba570ce71df3lu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEvent_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| constexpr uint64_t kUnknownInteractionsAjarProtocol_FlexibleEventErr_Ordinal = 0x4fbe0d51e074e5bclu; |
| constexpr ::fidl::MessageDynamicFlags kUnknownInteractionsAjarProtocol_FlexibleEventErr_DynamicFlags = ::fidl::MessageDynamicFlags::kFlexibleMethod; |
| } // 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 StrictTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result)>; |
| |
| virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0; |
| using FlexibleTwoWayCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result)>; |
| |
| virtual void FlexibleTwoWay(FlexibleTwoWayCallback callback) = 0; |
| using FlexibleTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result)>; |
| |
| virtual void FlexibleTwoWayErr(FlexibleTwoWayErrCallback callback) = 0; |
| using StrictEventCallback = |
| fit::function<void()>; |
| using StrictEventErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result)>; |
| using FlexibleEventCallback = |
| fit::function<void()>; |
| using FlexibleEventErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result)>; |
| }; |
| |
| class UnknownInteractionsProtocol_RequestDecoder { |
| public: |
| UnknownInteractionsProtocol_RequestDecoder() = default; |
| virtual ~UnknownInteractionsProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response); |
| virtual void StrictOneWay() = 0; |
| virtual void FlexibleOneWay() = 0; |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayErr() = 0; |
| virtual void FlexibleTwoWay() = 0; |
| virtual void FlexibleTwoWayErr() = 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 StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result result) = 0; |
| virtual void FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result result) = 0; |
| virtual void FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result result) = 0; |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result result) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result result) = 0; |
| }; |
| |
| class UnknownInteractionsProtocol_EventSender { |
| public: |
| virtual ~UnknownInteractionsProtocol_EventSender(); |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result result) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result result) = 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 StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* out_result) = 0; |
| virtual zx_status_t FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* out_result) = 0; |
| virtual zx_status_t FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* out_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.StrictTwoWayErr |
| void StrictTwoWayErr(StrictTwoWayErrCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWay |
| void FlexibleTwoWay(FlexibleTwoWayCallback callback) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayErr |
| void FlexibleTwoWayErr(FlexibleTwoWayErrCallback callback) override; |
| StrictEventCallback StrictEvent; |
| StrictEventErrCallback StrictEventErr; |
| FlexibleEventCallback FlexibleEvent; |
| FlexibleEventErrCallback FlexibleEventErr; |
| |
| 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 StrictEventErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictEventErr_Result result) override; |
| void FlexibleEvent() override; |
| void FlexibleEventErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleEventErr_Result result) 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.StrictTwoWayErr |
| zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_StrictTwoWayErr_Result* out_result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWay |
| zx_status_t FlexibleTwoWay(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWay_Result* out_result) override; |
| // cts-coverage-fidl-name:test.unknowninteractions/UnknownInteractionsProtocol.FlexibleTwoWayErr |
| zx_status_t FlexibleTwoWayErr(::test::unknowninteractions::UnknownInteractionsProtocol_FlexibleTwoWayErr_Result* out_result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<UnknownInteractionsProtocol>; |
| }; |
| #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 StrictTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result)>; |
| |
| virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0; |
| using StrictEventCallback = |
| fit::function<void()>; |
| using StrictEventErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result)>; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_RequestDecoder { |
| public: |
| UnknownInteractionsClosedProtocol_RequestDecoder() = default; |
| virtual ~UnknownInteractionsClosedProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response); |
| virtual void StrictOneWay() = 0; |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayErr() = 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 StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result result) = 0; |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result result) = 0; |
| }; |
| |
| class UnknownInteractionsClosedProtocol_EventSender { |
| public: |
| virtual ~UnknownInteractionsClosedProtocol_EventSender(); |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result result) = 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 StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* out_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.StrictTwoWayErr |
| void StrictTwoWayErr(StrictTwoWayErrCallback callback) override; |
| StrictEventCallback StrictEvent; |
| StrictEventErrCallback StrictEventErr; |
| |
| 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 StrictEventErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictEventErr_Result result) 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.StrictTwoWayErr |
| zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsClosedProtocol_StrictTwoWayErr_Result* out_result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<UnknownInteractionsClosedProtocol>; |
| }; |
| #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 StrictTwoWayErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result)>; |
| |
| virtual void StrictTwoWayErr(StrictTwoWayErrCallback callback) = 0; |
| using StrictEventCallback = |
| fit::function<void()>; |
| using StrictEventErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result)>; |
| using FlexibleEventCallback = |
| fit::function<void()>; |
| using FlexibleEventErrCallback = |
| fit::function<void(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result)>; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_RequestDecoder { |
| public: |
| UnknownInteractionsAjarProtocol_RequestDecoder() = default; |
| virtual ~UnknownInteractionsAjarProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response); |
| virtual void StrictOneWay() = 0; |
| virtual void FlexibleOneWay() = 0; |
| virtual void StrictTwoWay() = 0; |
| virtual void StrictTwoWayErr() = 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 StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result result) = 0; |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result result) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result result) = 0; |
| }; |
| |
| class UnknownInteractionsAjarProtocol_EventSender { |
| public: |
| virtual ~UnknownInteractionsAjarProtocol_EventSender(); |
| virtual void StrictEvent() = 0; |
| virtual void StrictEventErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result result) = 0; |
| virtual void FlexibleEvent() = 0; |
| virtual void FlexibleEventErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result result) = 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 StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* out_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.StrictTwoWayErr |
| void StrictTwoWayErr(StrictTwoWayErrCallback callback) override; |
| StrictEventCallback StrictEvent; |
| StrictEventErrCallback StrictEventErr; |
| FlexibleEventCallback FlexibleEvent; |
| FlexibleEventErrCallback FlexibleEventErr; |
| |
| 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 StrictEventErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictEventErr_Result result) override; |
| void FlexibleEvent() override; |
| void FlexibleEventErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_FlexibleEventErr_Result result) 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.StrictTwoWayErr |
| zx_status_t StrictTwoWayErr(::test::unknowninteractions::UnknownInteractionsAjarProtocol_StrictTwoWayErr_Result* out_result) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<UnknownInteractionsAjarProtocol>; |
| }; |
| #endif // __Fuchsia__ |
| |
| } // namespace unknowninteractions |
| } // namespace test |