| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include <fidl/test.protocols/cpp/markers.h> |
| #include <fidl/test.protocols/cpp/wire_types.h> |
| #include <lib/fidl/llcpp/wire_messaging.h> |
| |
| #ifdef __Fuchsia__ |
| |
| #include <lib/fidl/llcpp/client.h> |
| #include <lib/fidl/llcpp/connect_service.h> |
| #include <lib/fidl/llcpp/server.h> |
| #include <lib/fidl/llcpp/service_handler_interface.h> |
| #include <lib/fidl/llcpp/sync_call.h> |
| |
| #endif // __Fuchsia__ |
| |
| namespace test_protocols { |
| class WithAndWithoutRequestResponse; |
| |
| class Transitional; |
| |
| class MethodWithUnion; |
| |
| class WithProtocolEnds; |
| |
| class ManyParameters; |
| |
| class HandleRightsProtocol; |
| |
| class WithErrorSyntax; |
| |
| class DiscoverableProtocol; |
| |
| class ChannelProtocol; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseOnWithResponseRequestTable; |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| final { |
| static constexpr uint64_t value = 5413654872775949227lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final { |
| static constexpr uint64_t value = 1631193469798418024lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final { |
| static constexpr uint64_t value = 9037369643591427517lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| final { |
| static constexpr uint64_t value = 7326057319832554103lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final { |
| static constexpr uint64_t value = 2877322062572412767lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final { |
| static constexpr uint64_t value = 6417226585456833969lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse> |
| final { |
| static constexpr uint64_t value = 5397663296507358806lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse> |
| final { |
| static constexpr uint64_t value = 5811598563493228968lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails< |
| ::test_protocols::WithAndWithoutRequestResponse> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::WithAndWithoutRequestResponse>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::WithAndWithoutRequestResponse>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| final { |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final { |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final { |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final { |
| WireRequest() = default; |
| using ResponseType = ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final : public ::test_protocols::wire:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse base) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse( |
| std::move(base)) {} |
| explicit WireResponse(::fidl::StringView ret) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse{ |
| .ret = std::move(ret)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| body; |
| explicit TransactionalResponse(::fidl::StringView ret) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>(ret)) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| final : public ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest { |
| explicit WireRequest( |
| ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest base) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest( |
| std::move(base)) {} |
| explicit WireRequest(::fidl::StringView arg) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest{ |
| .arg = std::move(arg)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| body; |
| explicit TransactionalRequest(::fidl::StringView arg) |
| : body(::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>(arg)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final : public ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest { |
| explicit WireRequest( |
| ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest base) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest( |
| std::move(base)) {} |
| explicit WireRequest(::fidl::StringView arg) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest{ |
| .arg = std::move(arg)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| body; |
| explicit TransactionalRequest(::fidl::StringView arg) |
| : body(::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>(arg)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final { |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final : public ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest { |
| explicit WireRequest( |
| ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest base) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest( |
| std::move(base)) {} |
| explicit WireRequest(::fidl::StringView arg) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest{ |
| .arg = std::move(arg)} {} |
| WireRequest() = default; |
| using ResponseType = ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| body; |
| explicit TransactionalRequest(::fidl::StringView arg) |
| : body(::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>(arg)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final |
| : public ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse base) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse( |
| std::move(base)) {} |
| explicit WireResponse(::fidl::StringView ret) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse{ |
| .ret = std::move(ret)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| body; |
| explicit TransactionalResponse(::fidl::StringView ret) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>(ret)) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse> |
| final { |
| WireEvent() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalEvent() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse> |
| final : public ::test_protocols::wire:: |
| WithAndWithoutRequestResponseOnWithResponseRequest { |
| explicit WireEvent( |
| ::test_protocols::wire::WithAndWithoutRequestResponseOnWithResponseRequest |
| base) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseOnWithResponseRequest( |
| std::move(base)) {} |
| explicit WireEvent(::fidl::StringView ret) |
| : ::test_protocols::wire:: |
| WithAndWithoutRequestResponseOnWithResponseRequest{ |
| .ret = std::move(ret)} {} |
| WireEvent() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse> |
| body; |
| explicit TransactionalEvent(::fidl::StringView ret) |
| : body(::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>( |
| ret)) { |
| _InitHeader(); |
| } |
| TransactionalEvent() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestNoResponse>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>>:: |
| kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestNoResponse>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>) == |
| TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>, |
| ret) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>) == |
| TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>, |
| arg) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>) == |
| TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>, |
| arg) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>) == |
| TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireRequest<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| arg) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>) == |
| TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>, |
| ret) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>) == |
| TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits<::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseOnWithResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>) == |
| TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>, |
| header) == 0); |
| static_assert( |
| offsetof( |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithAndWithoutRequestResponseOnWithResponseRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr uint32_t kMaxOutOfLineV1 = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>) == |
| TypeTraits<::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>, |
| ret) == 0); |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>* |
| request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>* |
| request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<16> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>* request); |
| explicit WireUnownedResult(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>(bytes_.data() + |
| sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>(bytes_.data() + |
| sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>* request); |
| explicit WireUnownedResult(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>* request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse>* request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<16> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>* request); |
| explicit WireUnownedResult(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>(bytes_.data() + |
| sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>(bytes_.data() + |
| sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>* request); |
| explicit WireUnownedResult(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithAndWithoutRequestResponse> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| virtual void OnEmptyResponse( |
| ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>* |
| event) = 0; |
| virtual void OnWithResponse( |
| ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>* |
| event) = 0; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithAndWithoutRequestResponse>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| void OnEmptyResponse( |
| ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>* |
| event) override {} |
| void OnWithResponse( |
| ::fidl::WireEvent< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>* |
| event) override {} |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithAndWithoutRequestResponse> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler< |
| ::test_protocols::WithAndWithoutRequestResponse>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler< |
| ::test_protocols::WithAndWithoutRequestResponse>* event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |
| // |fidl::ClientEnd<::test_protocols::WithAndWithoutRequestResponse>|, avoiding |
| // setting up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse>> { |
| public: |
| // Allocates 32 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| NoRequestNoResponse() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| _request{}; |
| return ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 32 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| NoRequestEmptyResponse() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| _request{}; |
| return ::fidl::WireResult<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>(_client_end(), |
| &_request); |
| } |
| |
| // Allocates 16 bytes of request buffer on the stack. Response is |
| // heap-allocated. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| NoRequestWithResponse() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| _request{}; |
| return ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 16 bytes of response buffer on the stack. Request is |
| // heap-allocated. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| WithRequestNoResponse(::fidl::StringView arg) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| _request{arg}; |
| return ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 16 bytes of response buffer on the stack. Request is |
| // heap-allocated. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| WithRequestEmptyResponse(::fidl::StringView arg) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse> |
| _request{arg}; |
| return ::fidl::WireResult<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>(_client_end(), |
| &_request); |
| } |
| |
| // Request is heap-allocated. Response is heap-allocated. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| WithRequestWithResponse(::fidl::StringView arg) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse> |
| _request{arg}; |
| return ::fidl::WireResult<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>(_client_end(), |
| &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| _client_end() const { |
| return ::fidl::UnownedClientEnd< |
| ::test_protocols::WithAndWithoutRequestResponse>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| NoRequestNoResponse() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| NoRequestEmptyResponse() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>(_client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| NoRequestWithResponse() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| WithRequestNoResponse(::fidl::StringView arg) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| _request{arg}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| WithRequestEmptyResponse(::fidl::StringView arg) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse> |
| _request{arg}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>(_client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| WithRequestWithResponse(::fidl::StringView arg) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse> |
| _request{arg}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>(_client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::WithAndWithoutRequestResponse> |
| _client_end() const { |
| return ::fidl::UnownedClientEnd< |
| ::test_protocols::WithAndWithoutRequestResponse>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::fidl::StringView ret); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::fidl::StringView ret); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::fidl::StringView ret); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::fidl::StringView ret); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::WithAndWithoutRequestResponse; |
| |
| using NoRequestNoResponseCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>; |
| using NoRequestNoResponseRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>; |
| |
| virtual void NoRequestNoResponse( |
| NoRequestNoResponseRequestView request, |
| NoRequestNoResponseCompleter::Sync& completer) = 0; |
| |
| using NoRequestEmptyResponseCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>; |
| using NoRequestEmptyResponseRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>; |
| |
| virtual void NoRequestEmptyResponse( |
| NoRequestEmptyResponseRequestView request, |
| NoRequestEmptyResponseCompleter::Sync& completer) = 0; |
| |
| using NoRequestWithResponseCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>; |
| using NoRequestWithResponseRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>; |
| |
| virtual void NoRequestWithResponse( |
| NoRequestWithResponseRequestView request, |
| NoRequestWithResponseCompleter::Sync& completer) = 0; |
| |
| using WithRequestNoResponseCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>; |
| using WithRequestNoResponseRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>; |
| |
| virtual void WithRequestNoResponse( |
| WithRequestNoResponseRequestView request, |
| WithRequestNoResponseCompleter::Sync& completer) = 0; |
| |
| using WithRequestEmptyResponseCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>; |
| using WithRequestEmptyResponseRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>; |
| |
| virtual void WithRequestEmptyResponse( |
| WithRequestEmptyResponseRequestView request, |
| WithRequestEmptyResponseCompleter::Sync& completer) = 0; |
| |
| using WithRequestWithResponseCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>; |
| using WithRequestWithResponseRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>; |
| |
| virtual void WithRequestWithResponse( |
| WithRequestWithResponseRequestView request, |
| WithRequestWithResponseCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalRequestRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalRequestTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalOneWayRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalEventRequestTable; |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal<::test_protocols::Transitional::Request> |
| final { |
| static constexpr uint64_t value = 5849263021838298888lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal<::test_protocols::Transitional::OneWay> |
| final { |
| static constexpr uint64_t value = 4336658926562441191lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal<::test_protocols::Transitional::Event> |
| final { |
| static constexpr uint64_t value = 8507647465196374081lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails<::test_protocols::Transitional> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher<::test_protocols::Transitional> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::Transitional>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch(::fidl::WireServer<::test_protocols::Transitional>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::Transitional::Request> final |
| : public ::test_protocols::wire::TransitionalRequestRequest { |
| explicit WireRequest(::test_protocols::wire::TransitionalRequestRequest base) |
| : ::test_protocols::wire::TransitionalRequestRequest(std::move(base)) {} |
| explicit WireRequest(int64_t x) |
| : ::test_protocols::wire::TransitionalRequestRequest{.x = std::move(x)} {} |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::Transitional::Request> body; |
| explicit TransactionalRequest(int64_t x) |
| : body(::fidl::WireRequest<::test_protocols::Transitional::Request>(x)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::Transitional::Request> final |
| : public ::test_protocols::wire::TransitionalRequestTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire::TransitionalRequestTopResponse base) |
| : ::test_protocols::wire::TransitionalRequestTopResponse( |
| std::move(base)) {} |
| explicit WireResponse(int64_t y) |
| : ::test_protocols::wire::TransitionalRequestTopResponse{ |
| .y = std::move(y)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request> body; |
| explicit TransactionalResponse(int64_t y) |
| : body(::fidl::WireResponse<::test_protocols::Transitional::Request>(y)) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::Transitional::OneWay> final |
| : public ::test_protocols::wire::TransitionalOneWayRequest { |
| explicit WireRequest(::test_protocols::wire::TransitionalOneWayRequest base) |
| : ::test_protocols::wire::TransitionalOneWayRequest(std::move(base)) {} |
| explicit WireRequest(int64_t x) |
| : ::test_protocols::wire::TransitionalOneWayRequest{.x = std::move(x)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::Transitional::OneWay> body; |
| explicit TransactionalRequest(int64_t x) |
| : body(::fidl::WireRequest<::test_protocols::Transitional::OneWay>(x)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireEvent<::test_protocols::Transitional::Event> final |
| : public ::test_protocols::wire::TransitionalEventRequest { |
| explicit WireEvent(::test_protocols::wire::TransitionalEventRequest base) |
| : ::test_protocols::wire::TransitionalEventRequest(std::move(base)) {} |
| explicit WireEvent(int64_t x) |
| : ::test_protocols::wire::TransitionalEventRequest{.x = std::move(x)} {} |
| WireEvent() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalEvent< |
| ::test_protocols::Transitional::Event> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireEvent<::test_protocols::Transitional::Event> body; |
| explicit TransactionalEvent(int64_t x) |
| : body(::fidl::WireEvent<::test_protocols::Transitional::Event>(x)) { |
| _InitHeader(); |
| } |
| TransactionalEvent() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::Transitional::Request> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::Transitional::Request>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::Transitional::Request, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::Transitional::Request, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>> : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest<::test_protocols::Transitional::Request>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::Transitional::Request>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalRequestRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::Transitional::Request>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalRequestRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 8; |
| static constexpr uint32_t kPrimarySizeV1 = 8; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::Transitional::Request>) == |
| TypeTraits<::fidl::WireRequest<::test_protocols::Transitional::Request>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::Transitional::Request>, x) == |
| 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>> : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireResponse<::test_protocols::Transitional::Request>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalRequestTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalRequestTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 8; |
| static constexpr uint32_t kPrimarySizeV1 = 8; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse<::test_protocols::Transitional::Request>) == |
| TypeTraits<::fidl::WireResponse<::test_protocols::Transitional::Request>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireResponse<::test_protocols::Transitional::Request>, |
| y) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>> : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest<::test_protocols::Transitional::OneWay>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::Transitional::OneWay>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalOneWayRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest<::test_protocols::Transitional::OneWay>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalOneWayRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 8; |
| static constexpr uint32_t kPrimarySizeV1 = 8; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::Transitional::OneWay>) == |
| TypeTraits<::fidl::WireRequest<::test_protocols::Transitional::OneWay>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::Transitional::OneWay>, x) == |
| 0); |
| |
| template <> |
| struct IsFidlType< |
| ::fidl::internal::TransactionalEvent<::test_protocols::Transitional::Event>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireEvent<::test_protocols::Transitional::Event>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::internal::TransactionalEvent<::test_protocols::Transitional::Event>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireEvent<::test_protocols::Transitional::Event>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::Transitional::Event>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalEventRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::Transitional::Event>) == |
| TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::Transitional::Event>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::Transitional::Event>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::Transitional::Event>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireEvent<::test_protocols::Transitional::Event>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_TransitionalEventRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 8; |
| static constexpr uint32_t kPrimarySizeV1 = 8; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireEvent<::test_protocols::Transitional::Event>) == |
| TypeTraits<::fidl::WireEvent<::test_protocols::Transitional::Event>>:: |
| kPrimarySize); |
| static_assert(offsetof(::fidl::WireEvent<::test_protocols::Transitional::Event>, |
| x) == 0); |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult<::test_protocols::Transitional::Request> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::Transitional> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::Transitional> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>* Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>* Unwrap() |
| const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>* Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>& value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>& value() |
| const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>& value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>* operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>& operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<24> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::Transitional::Request> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::Transitional> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request>* request); |
| explicit WireUnownedResult(::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>* Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>* Unwrap() |
| const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>* Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::Transitional::Request>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>& value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>& value() |
| const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>& value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>* operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::Transitional::Request>& operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::Transitional::Request>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult<::test_protocols::Transitional::OneWay> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::Transitional> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>* request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::Transitional::OneWay> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::Transitional> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay>* request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::Transitional> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| virtual void Event( |
| ::fidl::WireEvent<::test_protocols::Transitional::Event>* event) = 0; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::Transitional> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::Transitional>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| void Event(::fidl::WireEvent<::test_protocols::Transitional::Event>* event) |
| override {} |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::Transitional> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::Transitional> { |
| public: |
| WireSyncEventHandler() = default; |
| void Event(::fidl::WireEvent<::test_protocols::Transitional::Event>* event) |
| override { |
| got_transitional_ = true; |
| } |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::Transitional> client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher<::test_protocols::Transitional> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler<::test_protocols::Transitional>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::Transitional>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |fidl::ClientEnd<::test_protocols::Transitional>|, |
| // avoiding setting up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl<::test_protocols::Transitional> final |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::Transitional>> { |
| public: |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::Transitional::Request> Request( |
| int64_t x) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request> |
| _request{x}; |
| return ::fidl::WireResult<::test_protocols::Transitional::Request>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::Transitional::OneWay> OneWay(int64_t x) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay> |
| _request{x}; |
| return ::fidl::WireResult<::test_protocols::Transitional::OneWay>( |
| _client_end(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::Transitional> _client_end() const { |
| return ::fidl::UnownedClientEnd<::test_protocols::Transitional>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl<::test_protocols::Transitional> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::Transitional>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::Transitional::Request> Request( |
| int64_t x) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::Request> |
| _request{x}; |
| return ::fidl::WireUnownedResult<::test_protocols::Transitional::Request>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::Transitional::OneWay> OneWay( |
| int64_t x) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::Transitional::OneWay> |
| _request{x}; |
| return ::fidl::WireUnownedResult<::test_protocols::Transitional::OneWay>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::Transitional> _client_end() const { |
| return ::fidl::UnownedClientEnd<::test_protocols::Transitional>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::Transitional::Request> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::Transitional::Request> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(int64_t y); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::Transitional::Request> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(int64_t y); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::Transitional::Request> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::Transitional::Request> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::Transitional> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::Transitional; |
| |
| using RequestCompleter = |
| ::fidl::internal::WireCompleter<::test_protocols::Transitional::Request>; |
| using RequestRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::Transitional::Request>; |
| |
| virtual void Request(RequestRequestView request, |
| RequestCompleter::Sync& completer) { |
| completer.Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| |
| using OneWayCompleter = |
| ::fidl::internal::WireCompleter<::test_protocols::Transitional::OneWay>; |
| using OneWayRequestView = |
| ::fidl::internal::WireRequestView<::test_protocols::Transitional::OneWay>; |
| |
| virtual void OneWay(OneWayRequestView request, |
| OneWayCompleter::Sync& completer) { |
| completer.Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_MethodWithUnionUnionMethodRequestTable; |
| |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::MethodWithUnion::UnionMethod> |
| final { |
| static constexpr uint64_t value = 4124874338266649112lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails<::test_protocols::MethodWithUnion> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher<::test_protocols::MethodWithUnion> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::MethodWithUnion>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::MethodWithUnion>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod> final |
| : public ::test_protocols::wire::MethodWithUnionUnionMethodRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::MethodWithUnionUnionMethodRequest base) |
| : ::test_protocols::wire::MethodWithUnionUnionMethodRequest( |
| std::move(base)) {} |
| explicit WireRequest(::test_protocols::wire::TheUnion u) |
| : ::test_protocols::wire::MethodWithUnionUnionMethodRequest{ |
| .u = std::move(u)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod> body; |
| explicit TransactionalRequest(::test_protocols::wire::TheUnion u) |
| : body( |
| ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod>( |
| u)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_MethodWithUnionUnionMethodRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(24 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_MethodWithUnionUnionMethodRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 24; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireRequest<::test_protocols::MethodWithUnion::UnionMethod>, |
| u) == 0); |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::MethodWithUnion::UnionMethod> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::MethodWithUnion> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>* request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::MethodWithUnion::UnionMethod> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::MethodWithUnion> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod>* request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::MethodWithUnion> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::MethodWithUnion>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::MethodWithUnion> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::MethodWithUnion> client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher<::test_protocols::MethodWithUnion> |
| final |
| : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler<::test_protocols::MethodWithUnion>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::MethodWithUnion>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |fidl::ClientEnd<::test_protocols::MethodWithUnion>|, |
| // avoiding setting up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl<::test_protocols::MethodWithUnion> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::MethodWithUnion>> { |
| public: |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::MethodWithUnion::UnionMethod> |
| UnionMethod(::test_protocols::wire::TheUnion u) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod> |
| _request{u}; |
| return ::fidl::WireResult<::test_protocols::MethodWithUnion::UnionMethod>( |
| _client_end(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::MethodWithUnion> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::MethodWithUnion>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::MethodWithUnion> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::MethodWithUnion>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::MethodWithUnion::UnionMethod> |
| UnionMethod(::test_protocols::wire::TheUnion u) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::MethodWithUnion::UnionMethod> |
| _request{u}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::MethodWithUnion::UnionMethod>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::MethodWithUnion> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::MethodWithUnion>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::MethodWithUnion; |
| |
| using UnionMethodCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::MethodWithUnion::UnionMethod>; |
| using UnionMethodRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::MethodWithUnion::UnionMethod>; |
| |
| virtual void UnionMethod(UnionMethodRequestView request, |
| UnionMethodCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsClientEndsRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsClientEndsTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsServerEndsRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsServerEndsTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsStructContainingEndsRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsStructContainingEndsTopResponseTable; |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| final { |
| static constexpr uint64_t value = 5870448041025163330lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| final { |
| static constexpr uint64_t value = 8115535094437022259lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final { |
| static constexpr uint64_t value = 4076866772260025813lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails<::test_protocols::WithProtocolEnds> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher< |
| ::test_protocols::WithProtocolEnds> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::WithProtocolEnds>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::WithProtocolEnds>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds> final |
| : public ::test_protocols::wire::WithProtocolEndsClientEndsRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::WithProtocolEndsClientEndsRequest base) |
| : ::test_protocols::wire::WithProtocolEndsClientEndsRequest( |
| std::move(base)) {} |
| explicit WireRequest( |
| ::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& in) |
| : ::test_protocols::wire::WithProtocolEndsClientEndsRequest{ |
| .in = std::move(in)} {} |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds> body; |
| explicit TransactionalRequest( |
| ::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& in) |
| : body( |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds>( |
| std::move(in))) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>; |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds> |
| final |
| : public ::test_protocols::wire::WithProtocolEndsClientEndsTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire::WithProtocolEndsClientEndsTopResponse base) |
| : ::test_protocols::wire::WithProtocolEndsClientEndsTopResponse( |
| std::move(base)) {} |
| explicit WireResponse( |
| ::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& out) |
| : ::test_protocols::wire::WithProtocolEndsClientEndsTopResponse{ |
| .out = std::move(out)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds> body; |
| explicit TransactionalResponse( |
| ::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& out) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>(std::move(out))) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds> final |
| : public ::test_protocols::wire::WithProtocolEndsServerEndsRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::WithProtocolEndsServerEndsRequest base) |
| : ::test_protocols::wire::WithProtocolEndsServerEndsRequest( |
| std::move(base)) {} |
| explicit WireRequest( |
| ::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& in) |
| : ::test_protocols::wire::WithProtocolEndsServerEndsRequest{ |
| .in = std::move(in)} {} |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds> body; |
| explicit TransactionalRequest( |
| ::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& in) |
| : body( |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds>( |
| std::move(in))) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>; |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds> |
| final |
| : public ::test_protocols::wire::WithProtocolEndsServerEndsTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire::WithProtocolEndsServerEndsTopResponse base) |
| : ::test_protocols::wire::WithProtocolEndsServerEndsTopResponse( |
| std::move(base)) {} |
| explicit WireResponse( |
| ::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& out) |
| : ::test_protocols::wire::WithProtocolEndsServerEndsTopResponse{ |
| .out = std::move(out)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds> body; |
| explicit TransactionalResponse( |
| ::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& out) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>(std::move(out))) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final : public ::test_protocols::wire:: |
| WithProtocolEndsStructContainingEndsRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::WithProtocolEndsStructContainingEndsRequest base) |
| : ::test_protocols::wire::WithProtocolEndsStructContainingEndsRequest( |
| std::move(base)) {} |
| explicit WireRequest(::test_protocols::wire::ProtocolEnds&& in) |
| : ::test_protocols::wire::WithProtocolEndsStructContainingEndsRequest{ |
| .in = std::move(in)} {} |
| WireRequest() = default; |
| using ResponseType = ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| body; |
| explicit TransactionalRequest(::test_protocols::wire::ProtocolEnds&& in) |
| : body(::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>( |
| std::move(in))) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>; |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final : public ::test_protocols::wire:: |
| WithProtocolEndsStructContainingEndsTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire::WithProtocolEndsStructContainingEndsTopResponse |
| base) |
| : ::test_protocols::wire::WithProtocolEndsStructContainingEndsTopResponse( |
| std::move(base)) {} |
| explicit WireResponse(::test_protocols::wire::ProtocolEnds&& out) |
| : ::test_protocols::wire::WithProtocolEndsStructContainingEndsTopResponse{ |
| .out = std::move(out)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| body; |
| explicit TransactionalResponse(::test_protocols::wire::ProtocolEnds&& out) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>( |
| std::move(out))) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithProtocolEnds::ClientEnds> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithProtocolEnds::ClientEnds>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithProtocolEnds::ClientEnds, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithProtocolEnds::ClientEnds, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithProtocolEnds::ServerEnds> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithProtocolEnds::ServerEnds>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithProtocolEnds::ServerEnds, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithProtocolEnds::ServerEnds, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> : public std::true_type {}; |
| template <> |
| struct IsResource< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_WithProtocolEndsClientEndsRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_WithProtocolEndsClientEndsRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ClientEnds>, |
| in) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> : public std::true_type {}; |
| template <> |
| struct IsResource< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsClientEndsTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsClientEndsTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>, |
| out) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> : public std::true_type {}; |
| template <> |
| struct IsResource< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_WithProtocolEndsServerEndsRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_WithProtocolEndsServerEndsRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireRequest<::test_protocols::WithProtocolEnds::ServerEnds>, |
| in) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> : public std::true_type {}; |
| template <> |
| struct IsResource< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsServerEndsTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsServerEndsTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>, |
| out) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsResource<::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsStructContainingEndsRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 4; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| header) == 0); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsStructContainingEndsRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 4; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>) == |
| TypeTraits<::fidl::WireRequest<::test_protocols::WithProtocolEnds:: |
| StructContainingEnds>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| in) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| template <> |
| struct IsResource<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsStructContainingEndsTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 4; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| header) == 0); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithProtocolEndsStructContainingEndsTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 4; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>) == |
| TypeTraits<::fidl::WireResponse<::test_protocols::WithProtocolEnds:: |
| StructContainingEnds>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>, |
| out) == 0); |
| #endif // __Fuchsia__ |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<24> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ClientEnds>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ClientEnds>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<24> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::ServerEnds>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithProtocolEnds::ServerEnds>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<32> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithProtocolEnds> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithProtocolEnds>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithProtocolEnds> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher<::test_protocols::WithProtocolEnds> |
| final |
| : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler<::test_protocols::WithProtocolEnds>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::WithProtocolEnds>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |fidl::ClientEnd<::test_protocols::WithProtocolEnds>|, |
| // avoiding setting up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl<::test_protocols::WithProtocolEnds> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::WithProtocolEnds>> { |
| public: |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithProtocolEnds::ClientEnds> ClientEnds( |
| ::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& in) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| _request{std::move(in)}; |
| return ::fidl::WireResult<::test_protocols::WithProtocolEnds::ClientEnds>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithProtocolEnds::ServerEnds> ServerEnds( |
| ::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& in) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| _request{std::move(in)}; |
| return ::fidl::WireResult<::test_protocols::WithProtocolEnds::ServerEnds>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| StructContainingEnds(::test_protocols::wire::ProtocolEnds&& in) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| _request{std::move(in)}; |
| return ::fidl::WireResult< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>(_client_end(), |
| &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::WithProtocolEnds> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::WithProtocolEnds>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::WithProtocolEnds::ClientEnds> |
| ClientEnds(::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& in) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| _request{std::move(in)}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithProtocolEnds::ClientEnds>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::WithProtocolEnds::ServerEnds> |
| ServerEnds(::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& in) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| _request{std::move(in)}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithProtocolEnds::ServerEnds>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| StructContainingEnds(::test_protocols::wire::ProtocolEnds&& in) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| _request{std::move(in)}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::WithProtocolEnds>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithProtocolEnds::ClientEnds> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& out); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& out); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithProtocolEnds::ClientEnds> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithProtocolEnds::ServerEnds> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& out); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& out); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithProtocolEnds::ServerEnds> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::test_protocols::wire::ProtocolEnds&& out); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::test_protocols::wire::ProtocolEnds&& out); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::WithProtocolEnds; |
| |
| using ClientEndsCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithProtocolEnds::ClientEnds>; |
| using ClientEndsRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithProtocolEnds::ClientEnds>; |
| |
| virtual void ClientEnds(ClientEndsRequestView request, |
| ClientEndsCompleter::Sync& completer) = 0; |
| |
| using ServerEndsCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithProtocolEnds::ServerEnds>; |
| using ServerEndsRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithProtocolEnds::ServerEnds>; |
| |
| virtual void ServerEnds(ServerEndsRequestView request, |
| ServerEndsCompleter::Sync& completer) = 0; |
| |
| using StructContainingEndsCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>; |
| using StructContainingEndsRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>; |
| |
| virtual void StructContainingEnds( |
| StructContainingEndsRequestView request, |
| StructContainingEndsCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ManyParametersFifteenRequestTable; |
| |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal<::test_protocols::ManyParameters::Fifteen> |
| final { |
| static constexpr uint64_t value = 6423043252952467815lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails<::test_protocols::ManyParameters> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher<::test_protocols::ManyParameters> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::ManyParameters>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::ManyParameters>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen> final |
| : public ::test_protocols::wire::ManyParametersFifteenRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::ManyParametersFifteenRequest base) |
| : ::test_protocols::wire::ManyParametersFifteenRequest(std::move(base)) {} |
| explicit WireRequest(bool p1, bool p2, bool p3, bool p4, bool p5, bool p6, |
| bool p7, bool p8, bool p9, bool p10, bool p11, bool p12, |
| bool p13, bool p14, bool p15) |
| : ::test_protocols::wire::ManyParametersFifteenRequest{ |
| .p1 = std::move(p1), |
| .p2 = std::move(p2), |
| .p3 = std::move(p3), |
| .p4 = std::move(p4), |
| .p5 = std::move(p5), |
| .p6 = std::move(p6), |
| .p7 = std::move(p7), |
| .p8 = std::move(p8), |
| .p9 = std::move(p9), |
| .p10 = std::move(p10), |
| .p11 = std::move(p11), |
| .p12 = std::move(p12), |
| .p13 = std::move(p13), |
| .p14 = std::move(p14), |
| .p15 = std::move(p15)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen> body; |
| explicit TransactionalRequest(bool p1, bool p2, bool p3, bool p4, bool p5, |
| bool p6, bool p7, bool p8, bool p9, bool p10, |
| bool p11, bool p12, bool p13, bool p14, |
| bool p15) |
| : body(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>( |
| p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ManyParametersFifteenRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(15 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(15 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ManyParametersFifteenRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 15; |
| static constexpr uint32_t kPrimarySizeV1 = 15; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>) == |
| TypeTraits<::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p1) == 0); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p2) == 1); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p3) == 2); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p4) == 3); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p5) == 4); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p6) == 5); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p7) == 6); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p8) == 7); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p9) == 8); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p10) == 9); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p11) == 10); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p12) == 11); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p13) == 12); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p14) == 13); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ManyParameters::Fifteen>, |
| p15) == 14); |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::ManyParameters::Fifteen> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ManyParameters> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>* request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::ManyParameters::Fifteen> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::ManyParameters> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen>* request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::ManyParameters> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::ManyParameters> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::ManyParameters>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::ManyParameters> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::ManyParameters> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::ManyParameters> client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher<::test_protocols::ManyParameters> |
| final |
| : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler<::test_protocols::ManyParameters>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::ManyParameters>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |fidl::ClientEnd<::test_protocols::ManyParameters>|, |
| // avoiding setting up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl<::test_protocols::ManyParameters> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::ManyParameters>> { |
| public: |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ManyParameters::Fifteen> Fifteen( |
| bool p1, bool p2, bool p3, bool p4, bool p5, bool p6, bool p7, bool p8, |
| bool p9, bool p10, bool p11, bool p12, bool p13, bool p14, bool p15) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen> |
| _request{p1, p2, p3, p4, p5, p6, p7, p8, |
| p9, p10, p11, p12, p13, p14, p15}; |
| return ::fidl::WireResult<::test_protocols::ManyParameters::Fifteen>( |
| _client_end(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::ManyParameters> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::ManyParameters>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::ManyParameters> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::ManyParameters>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::ManyParameters::Fifteen> Fifteen( |
| bool p1, bool p2, bool p3, bool p4, bool p5, bool p6, bool p7, bool p8, |
| bool p9, bool p10, bool p11, bool p12, bool p13, bool p14, bool p15) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ManyParameters::Fifteen> |
| _request{p1, p2, p3, p4, p5, p6, p7, p8, |
| p9, p10, p11, p12, p13, p14, p15}; |
| return ::fidl::WireUnownedResult<::test_protocols::ManyParameters::Fifteen>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::ManyParameters> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::ManyParameters>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::ManyParameters> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::ManyParameters; |
| |
| using FifteenCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::ManyParameters::Fifteen>; |
| using FifteenRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::ManyParameters::Fifteen>; |
| |
| virtual void Fifteen(FifteenRequestView request, |
| FifteenCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolNoResponseMethodRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolResponseMethodRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolResponseMethodTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolAnEventRequestTable; |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| final { |
| static constexpr uint64_t value = 1155044649514904573lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final { |
| static constexpr uint64_t value = 5956276128041940295lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::HandleRightsProtocol::AnEvent> |
| final { |
| static constexpr uint64_t value = 476727631355490611lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails< |
| ::test_protocols::HandleRightsProtocol> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher< |
| ::test_protocols::HandleRightsProtocol> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::HandleRightsProtocol>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::HandleRightsProtocol>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| final : public ::test_protocols::wire:: |
| HandleRightsProtocolNoResponseMethodRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::HandleRightsProtocolNoResponseMethodRequest base) |
| : ::test_protocols::wire::HandleRightsProtocolNoResponseMethodRequest( |
| std::move(base)) {} |
| explicit WireRequest(::zx::socket&& h) |
| : ::test_protocols::wire::HandleRightsProtocolNoResponseMethodRequest{ |
| .h = std::move(h)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| body; |
| explicit TransactionalRequest(::zx::socket&& h) |
| : body(::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>( |
| std::move(h))) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final |
| : public ::test_protocols::wire::HandleRightsProtocolResponseMethodRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::HandleRightsProtocolResponseMethodRequest base) |
| : ::test_protocols::wire::HandleRightsProtocolResponseMethodRequest( |
| std::move(base)) {} |
| explicit WireRequest(::zx::socket&& h) |
| : ::test_protocols::wire::HandleRightsProtocolResponseMethodRequest{ |
| .h = std::move(h)} {} |
| WireRequest() = default; |
| using ResponseType = ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| body; |
| explicit TransactionalRequest(::zx::socket&& h) |
| : body(::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>( |
| std::move(h))) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>; |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final : public ::test_protocols::wire:: |
| HandleRightsProtocolResponseMethodTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire::HandleRightsProtocolResponseMethodTopResponse |
| base) |
| : ::test_protocols::wire::HandleRightsProtocolResponseMethodTopResponse( |
| std::move(base)) {} |
| explicit WireResponse(::zx::socket&& h) |
| : ::test_protocols::wire::HandleRightsProtocolResponseMethodTopResponse{ |
| .h = std::move(h)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| body; |
| explicit TransactionalResponse(::zx::socket&& h) |
| : body(::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>( |
| std::move(h))) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent> final |
| : public ::test_protocols::wire::HandleRightsProtocolAnEventRequest { |
| explicit WireEvent( |
| ::test_protocols::wire::HandleRightsProtocolAnEventRequest base) |
| : ::test_protocols::wire::HandleRightsProtocolAnEventRequest( |
| std::move(base)) {} |
| explicit WireEvent(::zx::socket&& h) |
| : ::test_protocols::wire::HandleRightsProtocolAnEventRequest{ |
| .h = std::move(h)} {} |
| WireEvent() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent> body; |
| explicit TransactionalEvent(::zx::socket&& h) |
| : body(::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>( |
| std::move(h))) { |
| _InitHeader(); |
| } |
| TransactionalEvent() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsResource<::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_HandleRightsProtocolNoResponseMethodRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>, |
| header) == 0); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_HandleRightsProtocolNoResponseMethodRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>) == |
| TypeTraits<::fidl::WireRequest<::test_protocols::HandleRightsProtocol:: |
| NoResponseMethod>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>, |
| h) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsResource< |
| ::fidl::WireRequest<::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_HandleRightsProtocolResponseMethodRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| header) == 0); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_HandleRightsProtocolResponseMethodRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| h) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| template <> |
| struct IsResource<::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_HandleRightsProtocolResponseMethodTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| header) == 0); |
| static_assert( |
| offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits<::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_HandleRightsProtocolResponseMethodTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>, |
| h) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>> : public std::true_type { |
| }; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>> : public std::true_type { |
| }; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>> : public std::true_type { |
| }; |
| template <> |
| struct IsResource< |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_HandleRightsProtocolAnEventRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>) == |
| TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_HandleRightsProtocolAnEventRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>) == |
| TypeTraits<::fidl::WireEvent< |
| ::test_protocols::HandleRightsProtocol::AnEvent>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>, |
| h) == 0); |
| #endif // __Fuchsia__ |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>* request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>* request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* request); |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<24> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &( |
| reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::HandleRightsProtocol> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| virtual void AnEvent( |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>* |
| event) = 0; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::HandleRightsProtocol>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| void AnEvent( |
| ::fidl::WireEvent<::test_protocols::HandleRightsProtocol::AnEvent>* event) |
| override {} |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::HandleRightsProtocol> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> |
| client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher< |
| ::test_protocols::HandleRightsProtocol> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler< |
| ::test_protocols::HandleRightsProtocol>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::HandleRightsProtocol>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |
| // |fidl::ClientEnd<::test_protocols::HandleRightsProtocol>|, avoiding setting |
| // up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::HandleRightsProtocol>> { |
| public: |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| NoResponseMethod(::zx::socket&& h) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| _request{std::move(h)}; |
| return ::fidl::WireResult< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>(_client_end(), |
| &_request); |
| } |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| ResponseMethod(::zx::socket&& h) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| _request{std::move(h)}; |
| return ::fidl::WireResult< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>(_client_end(), |
| &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::HandleRightsProtocol>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| NoResponseMethod(::zx::socket&& h) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| _request{std::move(h)}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| ResponseMethod(::zx::socket&& h) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| _request{std::move(h)}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::HandleRightsProtocol>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::HandleRightsProtocol; |
| |
| using NoResponseMethodCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>; |
| using NoResponseMethodRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>; |
| |
| virtual void NoResponseMethod(NoResponseMethodRequestView request, |
| NoResponseMethodCompleter::Sync& completer) = 0; |
| |
| using ResponseMethodCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>; |
| using ResponseMethodRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>; |
| |
| virtual void ResponseMethod(ResponseMethodRequestView request, |
| ResponseMethodCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxResponseAsStructTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxErrorAsPrimitiveTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxErrorAsEnumTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxHandleInResultTopResponseTable; |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final { |
| static constexpr uint64_t value = 268248568430741139lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final { |
| static constexpr uint64_t value = 6930994461233198567lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| final { |
| static constexpr uint64_t value = 5491891352371277635lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| final { |
| static constexpr uint64_t value = 1371676333068455103lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails<::test_protocols::WithErrorSyntax> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher<::test_protocols::WithErrorSyntax> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::WithErrorSyntax>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::WithErrorSyntax>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final { |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final : public ::test_protocols::wire:: |
| WithErrorSyntaxResponseAsStructTopResponse { |
| using Result = test_protocols::wire::WithErrorSyntaxResponseAsStructResult; |
| |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructTopResponse base) |
| : ::test_protocols::wire::WithErrorSyntaxResponseAsStructTopResponse( |
| std::move(base)) {} |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResult result) |
| : ::test_protocols::wire::WithErrorSyntaxResponseAsStructTopResponse{ |
| .result = std::move(result)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| body; |
| explicit TransactionalResponse( |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResult result) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>(result)) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final { |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final : public ::test_protocols::wire:: |
| WithErrorSyntaxErrorAsPrimitiveTopResponse { |
| using Result = test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult; |
| |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveTopResponse base) |
| : ::test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveTopResponse( |
| std::move(base)) {} |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult result) |
| : ::test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveTopResponse{ |
| .result = std::move(result)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| body; |
| explicit TransactionalResponse( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult result) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>(result)) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| final { |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| final |
| : public ::test_protocols::wire::WithErrorSyntaxErrorAsEnumTopResponse { |
| using Result = test_protocols::wire::WithErrorSyntaxErrorAsEnumResult; |
| |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsEnumTopResponse base) |
| : ::test_protocols::wire::WithErrorSyntaxErrorAsEnumTopResponse( |
| std::move(base)) {} |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsEnumResult result) |
| : ::test_protocols::wire::WithErrorSyntaxErrorAsEnumTopResponse{ |
| .result = std::move(result)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum> body; |
| explicit TransactionalResponse( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsEnumResult result) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>(result)) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::WithErrorSyntax::HandleInResult> |
| final { |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult> |
| final |
| : public ::test_protocols::wire::WithErrorSyntaxHandleInResultTopResponse { |
| using Result = test_protocols::wire::WithErrorSyntaxHandleInResultResult; |
| |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxHandleInResultTopResponse base) |
| : ::test_protocols::wire::WithErrorSyntaxHandleInResultTopResponse( |
| std::move(base)) {} |
| explicit WireResponse( |
| ::test_protocols::wire::WithErrorSyntaxHandleInResultResult result) |
| : ::test_protocols::wire::WithErrorSyntaxHandleInResultTopResponse{ |
| .result = std::move(result)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult> body; |
| explicit TransactionalResponse( |
| ::test_protocols::wire::WithErrorSyntaxHandleInResultResult result) |
| : body(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>( |
| std::move(result))) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>>; |
| |
| using ApplicationError = uint32_t; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>>; |
| |
| using ApplicationError = uint32_t; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>>; |
| |
| using ApplicationError = ::test_protocols::wire::ErrorEnum; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::WithErrorSyntax::HandleInResult> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::HandleInResult>>; |
| |
| using ApplicationError = uint32_t; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::HandleInResult, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::WithErrorSyntax::HandleInResult, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ResponseAsStruct>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxResponseAsStructTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(24 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 24; |
| static constexpr uint32_t kMaxOutOfLineV1 = 24; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxResponseAsStructTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 24; |
| static constexpr uint32_t kMaxOutOfLine = 24; |
| static constexpr uint32_t kMaxOutOfLineV1 = 24; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>>::kPrimarySize); |
| static_assert(offsetof(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| result) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxErrorAsPrimitiveTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(24 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxErrorAsPrimitiveTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 24; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>>::kPrimarySize); |
| static_assert(offsetof(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>, |
| result) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsEnum>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsEnum>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::ErrorAsEnum>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxErrorAsEnumTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(24 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxErrorAsEnumTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 24; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>, |
| result) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::WithErrorSyntax::HandleInResult>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| template <> |
| struct IsResource< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxHandleInResultTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(24 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_WithErrorSyntaxHandleInResultTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 24; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 8; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>, |
| result) == 0); |
| #endif // __Fuchsia__ |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>* |
| Unwrap_NEW() { |
| return &result_.value(); |
| } |
| const ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>* |
| Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<64> bytes_; |
| std::optional<::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>> |
| result_ = std::nullopt; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else { |
| result_ = fitx::ok(&(raw_response->result.response())); |
| } |
| } |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else if (raw_response->result.is_response()) { |
| result_ = fitx::ok(&(raw_response->result.response())); |
| } |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>*>(bytes_) |
| ->body); |
| } |
| |
| ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>* |
| Unwrap_NEW() { |
| return &result_.value(); |
| } |
| const ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>* |
| Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| std::optional<::fitx::result< |
| uint32_t, |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResponse*>> |
| result_ = std::nullopt; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fitx::result<uint32_t>* Unwrap_NEW() { return &result_.value(); } |
| const ::fitx::result<uint32_t>* Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result<uint32_t>& value_NEW() { return *Unwrap_NEW(); } |
| const ::fitx::result<uint32_t>& value_NEW() const { return *Unwrap_NEW(); } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<48> bytes_; |
| std::optional<::fitx::result<uint32_t>> result_ = std::nullopt; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else { |
| result_ = fitx::ok(); |
| } |
| } |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else if (raw_response->result.is_response()) { |
| result_ = fitx::ok(); |
| } |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>*>(bytes_) |
| ->body); |
| } |
| |
| ::fitx::result<uint32_t>* Unwrap_NEW() { return &result_.value(); } |
| const ::fitx::result<uint32_t>* Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result<uint32_t>& value_NEW() { return *Unwrap_NEW(); } |
| const ::fitx::result<uint32_t>& value_NEW() const { return *Unwrap_NEW(); } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| std::optional<::fitx::result<uint32_t>> result_ = std::nullopt; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fitx::result<::test_protocols::wire::ErrorEnum>* Unwrap_NEW() { |
| return &result_.value(); |
| } |
| const ::fitx::result<::test_protocols::wire::ErrorEnum>* Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result<::test_protocols::wire::ErrorEnum>& value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fitx::result<::test_protocols::wire::ErrorEnum>& value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<48> bytes_; |
| std::optional<::fitx::result<::test_protocols::wire::ErrorEnum>> result_ = |
| std::nullopt; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) { |
| auto* raw_response = reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else { |
| result_ = fitx::ok(); |
| } |
| } |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else if (raw_response->result.is_response()) { |
| result_ = fitx::ok(); |
| } |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>*>(bytes_) |
| ->body); |
| } |
| |
| ::fitx::result<::test_protocols::wire::ErrorEnum>* Unwrap_NEW() { |
| return &result_.value(); |
| } |
| const ::fitx::result<::test_protocols::wire::ErrorEnum>* Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result<::test_protocols::wire::ErrorEnum>& value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fitx::result<::test_protocols::wire::ErrorEnum>& value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::ErrorAsEnum>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| std::optional<::fitx::result<::test_protocols::wire::ErrorEnum>> result_ = |
| std::nullopt; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>* |
| Unwrap_NEW() { |
| return &result_.value(); |
| } |
| const ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>* |
| Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<48> bytes_; |
| std::optional<::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>> |
| result_ = std::nullopt; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else { |
| result_ = fitx::ok(&(raw_response->result.response())); |
| } |
| } |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>*>( |
| bytes_ + sizeof(fidl_message_header_t)); |
| if (raw_response->result.is_err()) { |
| result_ = fitx::error(raw_response->result.err()); |
| } else if (raw_response->result.is_response()) { |
| result_ = fitx::ok(&(raw_response->result.response())); |
| } |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::WithErrorSyntax::HandleInResult>*>(bytes_) |
| ->body); |
| } |
| |
| ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>* |
| Unwrap_NEW() { |
| return &result_.value(); |
| } |
| const ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>* |
| Unwrap_NEW() const { |
| return &result_.value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::WithErrorSyntax::HandleInResult>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| std::optional<::fitx::result< |
| uint32_t, ::test_protocols::wire::WithErrorSyntaxHandleInResultResponse*>> |
| result_ = std::nullopt; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithErrorSyntax> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithErrorSyntax>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::WithErrorSyntax> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher<::test_protocols::WithErrorSyntax> |
| final |
| : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler<::test_protocols::WithErrorSyntax>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::WithErrorSyntax>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |fidl::ClientEnd<::test_protocols::WithErrorSyntax>|, |
| // avoiding setting up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl<::test_protocols::WithErrorSyntax> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::WithErrorSyntax>> { |
| public: |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| ResponseAsStruct() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| _request{}; |
| return ::fidl::WireResult< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>(_client_end(), |
| &_request); |
| } |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| ErrorAsPrimitive() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| _request{}; |
| return ::fidl::WireResult< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>(_client_end(), |
| &_request); |
| } |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| ErrorAsEnum() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| _request{}; |
| return ::fidl::WireResult<::test_protocols::WithErrorSyntax::ErrorAsEnum>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::HandleInResult> |
| HandleInResult() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| _request{}; |
| return ::fidl::WireResult< |
| ::test_protocols::WithErrorSyntax::HandleInResult>(_client_end(), |
| &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::WithErrorSyntax> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::WithErrorSyntax>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| ResponseAsStruct() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| ErrorAsPrimitive() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| ErrorAsEnum() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::WithErrorSyntax::HandleInResult> |
| HandleInResult() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::WithErrorSyntax::HandleInResult>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::WithErrorSyntax>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply( |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResult result); |
| void ReplySuccess(int64_t a, int64_t b, int64_t c); |
| void ReplyError(uint32_t error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply( |
| ::test_protocols::wire::WithErrorSyntaxResponseAsStructResult result); |
| void ReplySuccess(int64_t a, int64_t b, int64_t c); |
| void ReplyError(uint32_t error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult result); |
| void ReplySuccess(); |
| void ReplyError(uint32_t error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply( |
| ::test_protocols::wire::WithErrorSyntaxErrorAsPrimitiveResult result); |
| void ReplySuccess(); |
| void ReplyError(uint32_t error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::test_protocols::wire::WithErrorSyntaxErrorAsEnumResult result); |
| void ReplySuccess(); |
| void ReplyError(::test_protocols::wire::ErrorEnum error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::test_protocols::wire::WithErrorSyntaxErrorAsEnumResult result); |
| void ReplySuccess(); |
| void ReplyError(::test_protocols::wire::ErrorEnum error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::WithErrorSyntax::HandleInResult> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply( |
| ::test_protocols::wire::WithErrorSyntaxHandleInResultResult result); |
| void ReplySuccess(::zx::handle&& h); |
| void ReplyError(uint32_t error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply( |
| ::test_protocols::wire::WithErrorSyntaxHandleInResultResult result); |
| void ReplySuccess(::zx::handle&& h); |
| void ReplyError(uint32_t error); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::WithErrorSyntax::HandleInResult> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::WithErrorSyntax; |
| |
| using ResponseAsStructCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>; |
| using ResponseAsStructRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>; |
| |
| virtual void ResponseAsStruct(ResponseAsStructRequestView request, |
| ResponseAsStructCompleter::Sync& completer) = 0; |
| |
| using ErrorAsPrimitiveCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>; |
| using ErrorAsPrimitiveRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>; |
| |
| virtual void ErrorAsPrimitive(ErrorAsPrimitiveRequestView request, |
| ErrorAsPrimitiveCompleter::Sync& completer) = 0; |
| |
| using ErrorAsEnumCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>; |
| using ErrorAsEnumRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>; |
| |
| virtual void ErrorAsEnum(ErrorAsEnumRequestView request, |
| ErrorAsEnumCompleter::Sync& completer) = 0; |
| |
| using HandleInResultCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::WithErrorSyntax::HandleInResult>; |
| using HandleInResultRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::WithErrorSyntax::HandleInResult>; |
| |
| virtual void HandleInResult(HandleInResultRequestView request, |
| HandleInResultCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::DiscoverableProtocol::Method> |
| final { |
| static constexpr uint64_t value = 3455873048082739435lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails< |
| ::test_protocols::DiscoverableProtocol> { |
| static constexpr char DiscoverableName[] = |
| "test.protocols.DiscoverableProtocol"; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher< |
| ::test_protocols::DiscoverableProtocol> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::DiscoverableProtocol>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::DiscoverableProtocol>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::DiscoverableProtocol::Method> |
| final { |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::DiscoverableProtocol::Method>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::DiscoverableProtocol::Method>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::DiscoverableProtocol::Method>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::DiscoverableProtocol::Method> |
| final : public ::fidl::Status { |
| public: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocols::DiscoverableProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>* request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::DiscoverableProtocol::Method> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::DiscoverableProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method>* request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::DiscoverableProtocol> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::DiscoverableProtocol>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::DiscoverableProtocol> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::DiscoverableProtocol> |
| client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher< |
| ::test_protocols::DiscoverableProtocol> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler< |
| ::test_protocols::DiscoverableProtocol>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::DiscoverableProtocol>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |
| // |fidl::ClientEnd<::test_protocols::DiscoverableProtocol>|, avoiding setting |
| // up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::DiscoverableProtocol>> { |
| public: |
| // Allocates 32 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::DiscoverableProtocol::Method> Method() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method> |
| _request{}; |
| return ::fidl::WireResult<::test_protocols::DiscoverableProtocol::Method>( |
| _client_end(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::DiscoverableProtocol> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::DiscoverableProtocol>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::DiscoverableProtocol>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::DiscoverableProtocol::Method> |
| Method() { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::DiscoverableProtocol::Method> |
| _request{}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::DiscoverableProtocol::Method>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::DiscoverableProtocol> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::DiscoverableProtocol>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::DiscoverableProtocol; |
| |
| using MethodCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::DiscoverableProtocol::Method>; |
| using MethodRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::DiscoverableProtocol::Method>; |
| |
| virtual void Method(MethodRequestView request, |
| MethodCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMethodARequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolEventARequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMethodBRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMethodBTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolTakeHandleRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMutateSocketRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMutateSocketTopResponseTable; |
| } // namespace test_protocols |
| template <> |
| struct ::fidl::internal::WireOrdinal<::test_protocols::ChannelProtocol::MethodA> |
| final { |
| static constexpr uint64_t value = 3155008840945527714lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal<::test_protocols::ChannelProtocol::EventA> |
| final { |
| static constexpr uint64_t value = 2220452875311597006lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal<::test_protocols::ChannelProtocol::MethodB> |
| final { |
| static constexpr uint64_t value = 8903004957800778182lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| final { |
| static constexpr uint64_t value = 591935489944717925lu; |
| }; |
| template <> |
| struct ::fidl::internal::WireOrdinal< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| final { |
| static constexpr uint64_t value = 7411742788430590287lu; |
| }; |
| |
| namespace test_protocols {} // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::ProtocolDetails<::test_protocols::ChannelProtocol> {}; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireServerDispatcher<::test_protocols::ChannelProtocol> |
| final { |
| WireServerDispatcher() = delete; |
| static ::fidl::DispatchResult TryDispatch( |
| ::fidl::WireServer<::test_protocols::ChannelProtocol>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| static void Dispatch( |
| ::fidl::WireServer<::test_protocols::ChannelProtocol>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA> final |
| : public ::test_protocols::wire::ChannelProtocolMethodARequest { |
| explicit WireRequest( |
| ::test_protocols::wire::ChannelProtocolMethodARequest base) |
| : ::test_protocols::wire::ChannelProtocolMethodARequest(std::move(base)) { |
| } |
| explicit WireRequest(int64_t a, int64_t b) |
| : ::test_protocols::wire::ChannelProtocolMethodARequest{ |
| .a = std::move(a), .b = std::move(b)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA> body; |
| explicit TransactionalRequest(int64_t a, int64_t b) |
| : body(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA>( |
| a, b)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA> final |
| : public ::test_protocols::wire::ChannelProtocolEventARequest { |
| explicit WireEvent(::test_protocols::wire::ChannelProtocolEventARequest base) |
| : ::test_protocols::wire::ChannelProtocolEventARequest(std::move(base)) {} |
| explicit WireEvent(int64_t a, int64_t b) |
| : ::test_protocols::wire::ChannelProtocolEventARequest{ |
| .a = std::move(a), .b = std::move(b)} {} |
| WireEvent() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA> body; |
| explicit TransactionalEvent(int64_t a, int64_t b) |
| : body(::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>(a, |
| b)) { |
| _InitHeader(); |
| } |
| TransactionalEvent() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB> final |
| : public ::test_protocols::wire::ChannelProtocolMethodBRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::ChannelProtocolMethodBRequest base) |
| : ::test_protocols::wire::ChannelProtocolMethodBRequest(std::move(base)) { |
| } |
| explicit WireRequest(int64_t a, int64_t b) |
| : ::test_protocols::wire::ChannelProtocolMethodBRequest{ |
| .a = std::move(a), .b = std::move(b)} {} |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB> body; |
| explicit TransactionalRequest(int64_t a, int64_t b) |
| : body(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB>( |
| a, b)) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>; |
| |
| private: |
| void _InitHeader(); |
| }; |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB> final |
| : public ::test_protocols::wire::ChannelProtocolMethodBTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire::ChannelProtocolMethodBTopResponse base) |
| : ::test_protocols::wire::ChannelProtocolMethodBTopResponse( |
| std::move(base)) {} |
| explicit WireResponse(int64_t result) |
| : ::test_protocols::wire::ChannelProtocolMethodBTopResponse{ |
| .result = std::move(result)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB> body; |
| explicit TransactionalResponse(int64_t result) |
| : body(::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>( |
| result)) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle> final |
| : public ::test_protocols::wire::ChannelProtocolTakeHandleRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::ChannelProtocolTakeHandleRequest base) |
| : ::test_protocols::wire::ChannelProtocolTakeHandleRequest( |
| std::move(base)) {} |
| explicit WireRequest(::zx::handle&& h) |
| : ::test_protocols::wire::ChannelProtocolTakeHandleRequest{ |
| .h = std::move(h)} {} |
| WireRequest() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle> body; |
| explicit TransactionalRequest(::zx::handle&& h) |
| : body(::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle>( |
| std::move(h))) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::ChannelProtocol::TakeHandle> |
| final { |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| TransactionalResponse() { _InitHeader(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket> |
| final : public ::test_protocols::wire::ChannelProtocolMutateSocketRequest { |
| explicit WireRequest( |
| ::test_protocols::wire::ChannelProtocolMutateSocketRequest base) |
| : ::test_protocols::wire::ChannelProtocolMutateSocketRequest( |
| std::move(base)) {} |
| explicit WireRequest(::zx::socket&& a) |
| : ::test_protocols::wire::ChannelProtocolMutateSocketRequest{ |
| .a = std::move(a)} {} |
| WireRequest() = default; |
| using ResponseType = |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket> body; |
| explicit TransactionalRequest(::zx::socket&& a) |
| : body(::fidl::WireRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>(std::move(a))) { |
| _InitHeader(); |
| } |
| TransactionalRequest() { _InitHeader(); } |
| using ResponseType = ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>; |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket> |
| final |
| : public ::test_protocols::wire::ChannelProtocolMutateSocketTopResponse { |
| explicit WireResponse( |
| ::test_protocols::wire::ChannelProtocolMutateSocketTopResponse base) |
| : ::test_protocols::wire::ChannelProtocolMutateSocketTopResponse( |
| std::move(base)) {} |
| explicit WireResponse(::zx::socket&& b) |
| : ::test_protocols::wire::ChannelProtocolMutateSocketTopResponse{ |
| .b = std::move(b)} {} |
| WireResponse() = default; |
| }; |
| |
| template <> |
| struct ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| final { |
| FIDL_ALIGNDECL |
| fidl_message_header_t header; |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket> body; |
| explicit TransactionalResponse(::zx::socket&& b) |
| : body(::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>(std::move(b))) { |
| _InitHeader(); |
| } |
| TransactionalResponse() { _InitHeader(); } |
| void _CloseHandles() { body._CloseHandles(); } |
| |
| private: |
| void _InitHeader(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::ChannelProtocol::MethodB> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::ChannelProtocol::MethodB>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::ChannelProtocol::MethodB, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::ChannelProtocol::MethodB, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::ChannelProtocol::TakeHandle> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::ChannelProtocol::TakeHandle>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::ChannelProtocol::TakeHandle, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::ChannelProtocol::TakeHandle, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::WireMethodTypes< |
| ::test_protocols::ChannelProtocol::MutateSocket> { |
| using Completer = fidl::Completer<::fidl::internal::WireCompleterBase< |
| ::test_protocols::ChannelProtocol::MutateSocket>>; |
| |
| using Thenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::ChannelProtocol::MutateSocket, |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>, |
| ::fidl::internal::ChannelTransport>>; |
| |
| using BufferThenable = ::fidl::internal::WireThenableImpl< |
| ::test_protocols::ChannelProtocol::MutateSocket, |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>, |
| ::fidl::internal::ChannelTransport>>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMethodARequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMethodARequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::ChannelProtocol::MethodA>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA>, |
| a) == 0); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodA>, |
| b) == 8); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA>> : public std::true_type {}; |
| template <> |
| struct IsFidlType<::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolEventARequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA>) == |
| TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalEvent< |
| ::test_protocols::ChannelProtocol::EventA>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolEventARequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>) == |
| TypeTraits<::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>>:: |
| kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>, a) == |
| 0); |
| static_assert( |
| offsetof(::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>, b) == |
| 8); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMethodBRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(16 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMethodBRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 16; |
| static constexpr uint32_t kPrimarySizeV1 = 16; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::ChannelProtocol::MethodB>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB>, |
| a) == 0); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ChannelProtocol::MethodB>, |
| b) == 8); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMethodBTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(8 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert(sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMethodBTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 8; |
| static constexpr uint32_t kPrimarySizeV1 = 8; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MethodB>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>, |
| result) == 0); |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>> : public std::true_type {}; |
| template <> |
| struct IsResource< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolTakeHandleRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolTakeHandleRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>>::kPrimarySize); |
| static_assert( |
| offsetof(::fidl::WireRequest<::test_protocols::ChannelProtocol::TakeHandle>, |
| h) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>> : public std::true_type {}; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::TakeHandle>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>> : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::TakeHandle>> |
| : public std::false_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(0 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>, |
| header) == 0); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::TakeHandle>> { |
| static constexpr const fidl_type_t* kType = nullptr; |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kPrimarySize = 0; |
| static constexpr uint32_t kPrimarySizeV1 = 0; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>> : public std::true_type { |
| }; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>> : public std::true_type { |
| }; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>> : public std::true_type { |
| }; |
| template <> |
| struct IsResource< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMutateSocketRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>) == |
| TypeTraits<::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols::test_protocols_ChannelProtocolMutateSocketRequestTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kRequest; |
| }; |
| static_assert( |
| sizeof( |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket>) == |
| TypeTraits<::fidl::WireRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireRequest<::test_protocols::ChannelProtocol::MutateSocket>, |
| a) == 0); |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct IsFidlType<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>> : public std::true_type { |
| }; |
| template <> |
| struct IsFidlType< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>> |
| : public std::true_type {}; |
| template <> |
| struct IsFidlTransactionalMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>> : public std::true_type { |
| }; |
| template <> |
| struct IsFidlTransactionalMessage< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>> |
| : public std::false_type {}; |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>> : public std::true_type { |
| }; |
| template <> |
| struct IsResource< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>> |
| : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_ChannelProtocolMutateSocketTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kPrimarySizeV1 = |
| FIDL_ALIGN(4 + sizeof(fidl_message_header_t)); |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| |
| static_assert( |
| sizeof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>) == |
| TypeTraits<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>>::kPrimarySize); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>, |
| header) == 0); |
| static_assert(offsetof(::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>, |
| body) == sizeof(fidl_message_header_t)); |
| |
| template <> |
| struct TypeTraits< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>> { |
| static constexpr const fidl_type_t* kType = |
| &::test_protocols:: |
| test_protocols_ChannelProtocolMutateSocketTopResponseTable; |
| static constexpr uint32_t kMaxNumHandles = 1; |
| static constexpr uint32_t kPrimarySize = 4; |
| static constexpr uint32_t kPrimarySizeV1 = 4; |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr uint32_t kMaxOutOfLineV1 = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| static constexpr ::fidl::internal::TransactionalMessageKind kMessageKind = |
| ::fidl::internal::TransactionalMessageKind::kResponse; |
| }; |
| static_assert( |
| sizeof(::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>) == |
| TypeTraits<::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>>::kPrimarySize); |
| static_assert( |
| offsetof( |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>, |
| b) == 0); |
| #endif // __Fuchsia__ |
| |
| } // namespace fidl |
| namespace test_protocols { |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::ChannelProtocol::MethodA> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>* request); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::MethodA> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA>* request); |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::ChannelProtocol::MethodB> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MethodB>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MethodB>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<24> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::MethodB> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MethodB>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MethodB>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() = default; |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<16> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::TakeHandle>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() = default; |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireResult< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| final : public ::fidl::Status { |
| public: |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>* request); |
| WireResult(::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>* request, |
| zx_time_t _deadline); |
| explicit WireResult(const ::fidl::Status& result) : ::fidl::Status(result) {} |
| WireResult(WireResult&&) = delete; |
| WireResult(const WireResult&) = delete; |
| WireResult* operator=(WireResult&&) = delete; |
| WireResult* operator=(const WireResult&) = delete; |
| ~WireResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast< |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<const ::fidl::WireResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>*>( |
| bytes_.data() + sizeof(fidl_message_header_t)); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| ::fidl::internal::InlineMessageBuffer<24> bytes_; |
| }; |
| template <> |
| class [[nodiscard]] ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| final : public ::fidl::Status { |
| public: |
| explicit WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket>* request); |
| explicit WireUnownedResult( |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>* response) |
| : bytes_(reinterpret_cast<uint8_t*>(response)) {} |
| explicit WireUnownedResult(const ::fidl::Status& result) |
| : ::fidl::Status(result) {} |
| explicit WireUnownedResult( |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>>&& decoded, |
| ::fidl::internal::IncomingTransportContext context) |
| : ::fidl::Status(decoded) { |
| if (decoded.ok()) { |
| bytes_ = reinterpret_cast<uint8_t*>(decoded.PrimaryObject()); |
| } else { |
| bytes_ = nullptr; |
| } |
| decoded.ReleasePrimaryObject(); |
| } |
| WireUnownedResult(WireUnownedResult&&) = delete; |
| WireUnownedResult(const WireUnownedResult&) = delete; |
| WireUnownedResult* operator=(WireUnownedResult&&) = delete; |
| WireUnownedResult* operator=(const WireUnownedResult&) = delete; |
| ~WireUnownedResult() { |
| if (ok()) { |
| Unwrap()->_CloseHandles(); |
| } |
| } |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap_NEW() { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>*>(bytes_) |
| ->body); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| Unwrap_NEW() const { |
| ZX_DEBUG_ASSERT(ok()); |
| return &(reinterpret_cast<const ::fidl::internal::TransactionalResponse< |
| ::test_protocols::ChannelProtocol::MutateSocket>*>(bytes_) |
| ->body); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value() { |
| return *Unwrap(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value() const { |
| return *Unwrap(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value_NEW() { |
| return *Unwrap_NEW(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| value_NEW() const { |
| return *Unwrap_NEW(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| operator->() { |
| return &value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>* |
| operator->() const { |
| return &value(); |
| } |
| |
| ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| operator*() { |
| return value(); |
| } |
| const ::fidl::WireResponse<::test_protocols::ChannelProtocol::MutateSocket>& |
| operator*() const { |
| return value(); |
| } |
| |
| private: |
| uint8_t* bytes_; |
| }; |
| template <> |
| class ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::ChannelProtocol> { |
| public: |
| WireEventHandlerInterface() = default; |
| virtual ~WireEventHandlerInterface() = default; |
| virtual void EventA( |
| ::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>* event) = 0; |
| }; |
| |
| template <> |
| class ::fidl::WireAsyncEventHandler<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::ChannelProtocol>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| WireAsyncEventHandler() = default; |
| void EventA(::fidl::WireEvent<::test_protocols::ChannelProtocol::EventA>* |
| event) override {} |
| }; |
| |
| template <> |
| class ::fidl::WireSyncEventHandler<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::WireEventHandlerInterface< |
| ::test_protocols::ChannelProtocol> { |
| public: |
| WireSyncEventHandler() = default; |
| |
| // Handle all possible events defined in this protocol. |
| // Blocks to consume exactly one message from the channel, then call the |
| // corresponding virtual method. |
| ::fidl::Status HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> client_end); |
| |
| private: |
| [[maybe_unused]] bool got_transitional_ = false; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventDispatcher<::test_protocols::ChannelProtocol> |
| final |
| : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::WireAsyncEventHandler<::test_protocols::ChannelProtocol>> { |
| public: |
| explicit WireEventDispatcher( |
| ::fidl::WireAsyncEventHandler<::test_protocols::ChannelProtocol>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) override; |
| }; |
| |
| // Methods to make a sync FIDL call directly on an unowned handle or a |
| // const reference to a |fidl::ClientEnd<::test_protocols::ChannelProtocol>|, |
| // avoiding setting up a client. |
| template <> |
| class ::fidl::internal::WireSyncClientImpl<::test_protocols::ChannelProtocol> |
| final : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireSyncClientImpl< |
| ::test_protocols::ChannelProtocol>> { |
| public: |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ChannelProtocol::MethodA> MethodA( |
| int64_t a, int64_t b) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA> |
| _request{a, b}; |
| return ::fidl::WireResult<::test_protocols::ChannelProtocol::MethodA>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 56 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ChannelProtocol::MethodB> MethodB( |
| int64_t a, int64_t b) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB> |
| _request{a, b}; |
| return ::fidl::WireResult<::test_protocols::ChannelProtocol::MethodB>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ChannelProtocol::TakeHandle> TakeHandle( |
| ::zx::handle&& h) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| _request{std::move(h)}; |
| return ::fidl::WireResult<::test_protocols::ChannelProtocol::TakeHandle>( |
| _client_end(), &_request); |
| } |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ChannelProtocol::MutateSocket> |
| MutateSocket(::zx::socket&& a) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| _request{std::move(a)}; |
| return ::fidl::WireResult<::test_protocols::ChannelProtocol::MutateSocket>( |
| _client_end(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::ChannelProtocol> |
| final : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireSyncBufferClientImpl< |
| ::test_protocols::ChannelProtocol>> { |
| public: |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::ChannelProtocol::MethodA> MethodA( |
| int64_t a, int64_t b) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodA> |
| _request{a, b}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::MethodA>(_client_end(), _allocator(), |
| &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::ChannelProtocol::MethodB> MethodB( |
| int64_t a, int64_t b) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MethodB> |
| _request{a, b}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::MethodB>(_client_end(), _allocator(), |
| &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::ChannelProtocol::TakeHandle> |
| TakeHandle(::zx::handle&& h) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| _request{std::move(h)}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::TakeHandle>(_client_end(), |
| _allocator(), &_request); |
| } |
| |
| // Caller provides the backing storage for FIDL message via an argument to |
| // `.buffer()`. |
| ::fidl::WireUnownedResult<::test_protocols::ChannelProtocol::MutateSocket> |
| MutateSocket(::zx::socket&& a) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| _request{std::move(a)}; |
| return ::fidl::WireUnownedResult< |
| ::test_protocols::ChannelProtocol::MutateSocket>( |
| _client_end(), _allocator(), &_request); |
| } |
| |
| private: |
| ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol> _client_end() |
| const { |
| return ::fidl::UnownedClientEnd<::test_protocols::ChannelProtocol>( |
| _transport().get<::fidl::internal::ChannelTransport>()); |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::ChannelProtocol::MethodB> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::ChannelProtocol::MethodB> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(int64_t result); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::ChannelProtocol::MethodB> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(int64_t result); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::ChannelProtocol::MethodB> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::ChannelProtocol::MethodB> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::ChannelProtocol::TakeHandle> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::ChannelProtocol::TakeHandle> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| : public ::fidl::internal::CompleterImplBase< |
| ::test_protocols::ChannelProtocol::MutateSocket> { |
| public: |
| using CompleterImplBase::CompleterImplBase; |
| |
| void Reply(::zx::socket&& b); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferCompleterImpl< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| : public ::fidl::internal::BufferCompleterImplBase { |
| public: |
| using BufferCompleterImplBase::BufferCompleterImplBase; |
| |
| void Reply(::zx::socket&& b); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireCompleterBase< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| : public ::fidl::CompleterBase, |
| public ::fidl::internal::WireCompleterImpl< |
| ::test_protocols::ChannelProtocol::MutateSocket> { |
| public: |
| WireCompleterBase(::fidl::Transaction* transaction, bool owned, |
| bool expects_reply) |
| : CompleterBase(transaction, owned, expects_reply), |
| WireCompleterImpl(this) {} |
| WireCompleterBase(WireCompleterBase&& other) noexcept |
| : CompleterBase(std::move(other)), WireCompleterImpl(this) {} |
| WireCompleterBase& operator=(WireCompleterBase&& other) noexcept { |
| CompleterBase::operator=(std::move(other)); |
| WireCompleterImpl::_set_core(this); |
| return *this; |
| } |
| }; |
| |
| // Pure-virtual interface to be implemented by a server. |
| // This interface uses typed channels (i.e. |fidl::ClientEnd<SomeProtocol>| |
| // and |fidl::ServerEnd<SomeProtocol>|). |
| template <> |
| class ::fidl::WireServer<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| WireServer() = default; |
| virtual ~WireServer() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::ChannelProtocol; |
| |
| using MethodACompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::ChannelProtocol::MethodA>; |
| using MethodARequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::ChannelProtocol::MethodA>; |
| |
| virtual void MethodA(MethodARequestView request, |
| MethodACompleter::Sync& completer) = 0; |
| |
| using MethodBCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::ChannelProtocol::MethodB>; |
| using MethodBRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::ChannelProtocol::MethodB>; |
| |
| virtual void MethodB(MethodBRequestView request, |
| MethodBCompleter::Sync& completer) = 0; |
| |
| using TakeHandleCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::ChannelProtocol::TakeHandle>; |
| using TakeHandleRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::ChannelProtocol::TakeHandle>; |
| |
| virtual void TakeHandle(TakeHandleRequestView request, |
| TakeHandleCompleter::Sync& completer) = 0; |
| |
| using MutateSocketCompleter = ::fidl::internal::WireCompleter< |
| ::test_protocols::ChannelProtocol::MutateSocket>; |
| using MutateSocketRequestView = ::fidl::internal::WireRequestView< |
| ::test_protocols::ChannelProtocol::MutateSocket>; |
| |
| virtual void MutateSocket(MutateSocketRequestView request, |
| MutateSocketCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| namespace fidl { |
| |
| #ifdef __Fuchsia__ |
| } // namespace fidl |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| |
| // Allocates 32 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::Status NoRequestNoResponse(); |
| |
| // Allocates 16 bytes of response buffer on the stack. Request is |
| // heap-allocated. |
| ::fidl::Status WithRequestNoResponse(::fidl::StringView arg); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| // Allocates 16 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| NoRequestEmptyResponse(); |
| // Allocates 16 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| NoRequestWithResponse(); |
| // The request and callback are allocated on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| WithRequestEmptyResponse(::fidl::StringView arg); |
| // The request and callback are allocated on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| WithRequestWithResponse(::fidl::StringView arg); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status NoRequestNoResponse(); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status WithRequestNoResponse(::fidl::StringView arg); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| NoRequestEmptyResponse(); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| NoRequestWithResponse(); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| WithRequestEmptyResponse(::fidl::StringView arg); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| WithRequestWithResponse(::fidl::StringView arg); |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| |
| // Allocates 32 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| NoRequestEmptyResponse(); |
| |
| // Allocates 16 bytes of request buffer on the stack. Response is |
| // heap-allocated. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| NoRequestWithResponse(); |
| |
| // Allocates 16 bytes of response buffer on the stack. Request is |
| // heap-allocated. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| WithRequestEmptyResponse(::fidl::StringView arg); |
| |
| // Request is heap-allocated. Response is heap-allocated. |
| ::fidl::WireResult< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| WithRequestWithResponse(::fidl::StringView arg); |
| }; |
| namespace fidl { |
| #endif // __Fuchsia__ |
| |
| } // namespace fidl |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| fidl::Status OnEmptyResponse(); |
| |
| fidl::Status OnWithResponse(::fidl::StringView ret); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| |
| fidl::Status OnEmptyResponse(); |
| |
| fidl::Status OnWithResponse(::fidl::StringView ret); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| fidl::Status OnEmptyResponse(); |
| |
| fidl::Status OnWithResponse(::fidl::StringView ret); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| |
| fidl::Status OnEmptyResponse(); |
| |
| fidl::Status OnWithResponse(::fidl::StringView ret); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl<::test_protocols::Transitional> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::Status OneWay(int64_t x); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl<::test_protocols::Transitional> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::Transitional> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| // Allocates 24 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable<::test_protocols::Transitional::Request> |
| Request(int64_t x); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::Transitional> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status OneWay(int64_t x); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::Transitional> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::Transitional> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable<::test_protocols::Transitional::Request> |
| Request(int64_t x); |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl<::test_protocols::Transitional> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::Transitional> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::Transitional::Request> Request( |
| int64_t x); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender<::test_protocols::Transitional> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| fidl::Status Event(int64_t x); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::Transitional> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| |
| fidl::Status Event(int64_t x); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::Transitional> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender<::test_protocols::Transitional>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| fidl::Status Event(int64_t x); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender<::test_protocols::Transitional> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::Transitional>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| |
| fidl::Status Event(int64_t x); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::Status UnionMethod(::test_protocols::wire::TheUnion u); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::MethodWithUnion> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::MethodWithUnion> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status UnionMethod(::test_protocols::wire::TheUnion u); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::MethodWithUnion> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::MethodWithUnion> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl< |
| ::test_protocols::MethodWithUnion> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::MethodWithUnion> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender< |
| ::test_protocols::MethodWithUnion>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::MethodWithUnion>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::WithProtocolEnds> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithProtocolEnds> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| // Allocates 24 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable<::test_protocols::WithProtocolEnds::ClientEnds> |
| ClientEnds(::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& in); |
| // Allocates 24 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable<::test_protocols::WithProtocolEnds::ServerEnds> |
| ServerEnds(::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& in); |
| // Allocates 32 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| StructContainingEnds(::test_protocols::wire::ProtocolEnds&& in); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::WithProtocolEnds> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::WithProtocolEnds> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| ClientEnds(::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& in); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| ServerEnds(::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& in); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| StructContainingEnds(::test_protocols::wire::ProtocolEnds&& in); |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl< |
| ::test_protocols::WithProtocolEnds> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithProtocolEnds> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithProtocolEnds::ClientEnds> ClientEnds( |
| ::fidl::ClientEnd<::test_protocols::DiscoverableProtocol>&& in); |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithProtocolEnds::ServerEnds> ServerEnds( |
| ::fidl::ServerEnd<::test_protocols::DiscoverableProtocol>&& in); |
| |
| // Allocates 64 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| StructContainingEnds(::test_protocols::wire::ProtocolEnds&& in); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender< |
| ::test_protocols::WithProtocolEnds>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::WithProtocolEnds>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::ManyParameters> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::Status Fifteen(bool p1, bool p2, bool p3, bool p4, bool p5, bool p6, |
| bool p7, bool p8, bool p9, bool p10, bool p11, |
| bool p12, bool p13, bool p14, bool p15); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::ManyParameters> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::ManyParameters> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::ManyParameters> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status Fifteen(bool p1, bool p2, bool p3, bool p4, bool p5, bool p6, |
| bool p7, bool p8, bool p9, bool p10, bool p11, |
| bool p12, bool p13, bool p14, bool p15); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::ManyParameters> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::ManyParameters> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl<::test_protocols::ManyParameters> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::ManyParameters> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender<::test_protocols::ManyParameters> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::ManyParameters> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::ManyParameters> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender<::test_protocols::ManyParameters>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender<::test_protocols::ManyParameters> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::ManyParameters>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::Status NoResponseMethod(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::HandleRightsProtocol> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| // Allocates 24 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| ResponseMethod(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status NoResponseMethod(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::HandleRightsProtocol> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| ResponseMethod(::zx::socket&& h); |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::HandleRightsProtocol> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| ResponseMethod(::zx::socket&& h); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender< |
| ::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| fidl::Status AnEvent(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| |
| fidl::Status AnEvent(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender< |
| ::test_protocols::HandleRightsProtocol>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| fidl::Status AnEvent(::zx::socket&& h); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::HandleRightsProtocol>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| |
| fidl::Status AnEvent(::zx::socket&& h); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::WithErrorSyntax> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithErrorSyntax> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| // Allocates 16 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| ResponseAsStruct(); |
| // Allocates 16 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| ErrorAsPrimitive(); |
| // Allocates 16 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable<::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| ErrorAsEnum(); |
| // Allocates 16 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| HandleInResult(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::WithErrorSyntax> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::WithErrorSyntax> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| ResponseAsStruct(); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| ErrorAsPrimitive(); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| ErrorAsEnum(); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| HandleInResult(); |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl< |
| ::test_protocols::WithErrorSyntax> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::WithErrorSyntax> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| |
| // Allocates 72 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| ResponseAsStruct(); |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| ErrorAsPrimitive(); |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| ErrorAsEnum(); |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::WithErrorSyntax::HandleInResult> |
| HandleInResult(); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender< |
| ::test_protocols::WithErrorSyntax>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::WithErrorSyntax>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| |
| // Allocates 32 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::Status Method(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::DiscoverableProtocol> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status Method(); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::DiscoverableProtocol> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::DiscoverableProtocol> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender< |
| ::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender< |
| ::test_protocols::DiscoverableProtocol>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::DiscoverableProtocol>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::ClientImplBase { |
| public: |
| using ClientImplBase::ClientImplBase; |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::Status MethodA(int64_t a, int64_t b); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncClientImpl< |
| ::test_protocols::ChannelProtocol> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::ChannelProtocol> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| // Allocates 32 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable<::test_protocols::ChannelProtocol::MethodB> |
| MethodB(int64_t a, int64_t b); |
| // Allocates 24 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable<::test_protocols::ChannelProtocol::TakeHandle> |
| TakeHandle(::zx::handle&& h); |
| // Allocates 24 bytes of request buffer on the stack. The callback is stored |
| // on the heap. |
| ::fidl::internal::WireThenable< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| MutateSocket(::zx::socket&& a); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::BufferClientImplBase { |
| public: |
| using BufferClientImplBase::BufferClientImplBase; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::Status MethodA(int64_t a, int64_t b); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocols::ChannelProtocol> |
| final : public ::fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocols::ChannelProtocol> { |
| public: |
| using WireWeakOnewayBufferClientImpl::WireWeakOnewayBufferClientImpl; |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::ChannelProtocol::MethodB> |
| MethodB(int64_t a, int64_t b); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| TakeHandle(::zx::handle&& h); |
| |
| // Caller provides the backing storage for FIDL message. |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| MutateSocket(::zx::socket&& a); |
| }; |
| template <> |
| class ::fidl::internal::WireWeakSyncClientImpl< |
| ::test_protocols::ChannelProtocol> |
| final : public ::fidl::internal::WireWeakOnewayClientImpl< |
| ::test_protocols::ChannelProtocol> { |
| public: |
| using WireWeakOnewayClientImpl::WireWeakOnewayClientImpl; |
| |
| // Allocates 56 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ChannelProtocol::MethodB> MethodB( |
| int64_t a, int64_t b); |
| |
| // Allocates 40 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ChannelProtocol::TakeHandle> TakeHandle( |
| ::zx::handle&& h); |
| |
| // Allocates 48 bytes of message buffer on the stack. No heap allocation |
| // necessary. |
| ::fidl::WireResult<::test_protocols::ChannelProtocol::MutateSocket> |
| MutateSocket(::zx::socket&& a); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::WireWeakEventSender<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| fidl::Status EventA(int64_t a, int64_t b); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireWeakBufferEventSender< |
| ::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::WeakBufferEventSenderBase { |
| public: |
| using WeakBufferEventSenderBase::WeakBufferEventSenderBase; |
| |
| fidl::Status EventA(int64_t a, int64_t b); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireEventSender<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::WireEventSender< |
| ::test_protocols::ChannelProtocol>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| fidl::Status EventA(int64_t a, int64_t b); |
| }; |
| |
| template <> |
| class ::fidl::internal::WireBufferEventSender<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::SyncEndpointBufferVeneer< |
| ::fidl::internal::WireBufferEventSender< |
| ::test_protocols::ChannelProtocol>> { |
| public: |
| using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer; |
| |
| fidl::Status EventA(int64_t a, int64_t b); |
| }; |
| #endif // __Fuchsia__ |