| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <fidl/test.protocollayouts/cpp/wire_messaging.h> |
| |
| #include <memory> |
| |
| namespace test_protocollayouts { |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OneWayAnonComposed_Ordinal = |
| 467706262354916833lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OneWayAnonComposed_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolOneWayAnonComposedRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_TwoWayAnonComposed_Ordinal = |
| 1634702755099390832lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayAnonComposed_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolTwoWayAnonComposedRequestTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolTwoWayAnonComposedResponseTable; |
| |
| [[maybe_unused]] constexpr uint64_t |
| kMainProtocol_TwoWayAnonComposedWithError_Ordinal = 3374101322700362141lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolTwoWayAnonComposedWithErrorRequestTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolTwoWayAnonComposedWithErrorTopResponseTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnAnonComposed_Ordinal = |
| 9198778981238868491lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnAnonComposed_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolOnAnonComposedRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t |
| kMainProtocol_OnAnonComposedWithError_Ordinal = 712214127111113275lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnAnonComposedWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolOnAnonComposedWithErrorRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OneWayNamedComposed_Ordinal = |
| 6735359826241449560lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OneWayNamedComposed_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportTablePayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_TwoWayNamedComposed_Ordinal = |
| 1110122450485917712lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayNamedComposed_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportUnionPayloadTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportTablePayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t |
| kMainProtocol_TwoWayNamedComposedWithError_Ordinal = 3520341666774118271lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportTablePayloadTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolTwoWayNamedComposedWithErrorTopResponseTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnNamedComposed_Ordinal = |
| 6802961197456477674lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnNamedComposed_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportUnionPayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t |
| kMainProtocol_OnNamedComposedWithError_Ordinal = 7488207288618998795lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnNamedComposedWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ComposedProtocolOnNamedComposedWithErrorRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OneWayImport_Ordinal = |
| 374039999976906043lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OneWayImport_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportTablePayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_TwoWayImport_Ordinal = |
| 3167860988423964164lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayImport_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportUnionPayloadTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportTablePayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t |
| kMainProtocol_TwoWayImportWithError_Ordinal = 4837028007581646602lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayImportWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportTablePayloadTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolTwoWayImportWithErrorTopResponseTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnImport_Ordinal = |
| 6584793811321990352lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnImport_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_imported_ImportUnionPayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnImportWithError_Ordinal = |
| 1123803631971094487lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnImportWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolOnImportWithErrorRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OneWayLocal_Ordinal = |
| 6085941264859402051lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OneWayLocal_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t test_protocollayouts_LocalTablePayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_TwoWayLocal_Ordinal = |
| 7763901300032164763lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayLocal_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t test_protocollayouts_LocalUnionPayloadTable; |
| |
| extern "C" const fidl_type_t test_protocollayouts_LocalTablePayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_TwoWayLocalWithError_Ordinal = |
| 5609487496960056151lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayLocalWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t test_protocollayouts_LocalTablePayloadTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolTwoWayLocalWithErrorTopResponseTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnLocal_Ordinal = |
| 4199259762307646332lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnLocal_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t test_protocollayouts_LocalUnionPayloadTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnLocalWithError_Ordinal = |
| 8767483445230259748lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnLocalWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolOnLocalWithErrorRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OneWayAnon_Ordinal = |
| 4203317713771984620lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OneWayAnon_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolOneWayAnonRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_TwoWayAnon_Ordinal = |
| 7435080039097281487lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayAnon_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolTwoWayAnonRequestTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolTwoWayAnonResponseTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_TwoWayAnonWithError_Ordinal = |
| 7770394869745610225lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_TwoWayAnonWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolTwoWayAnonWithErrorRequestTable; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolTwoWayAnonWithErrorTopResponseTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnAnon_Ordinal = |
| 7275479350674227467lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnAnon_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolOnAnonRequestTable; |
| |
| [[maybe_unused]] constexpr uint64_t kMainProtocol_OnAnonWithError_Ordinal = |
| 3672186790919812761lu; |
| |
| [[maybe_unused]] constexpr ::fidl::MessageDynamicFlags |
| kMainProtocol_OnAnonWithError_DynamicFlags = |
| ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| extern "C" const fidl_type_t |
| test_protocollayouts_MainProtocolOnAnonWithErrorRequestTable; |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnonComposed>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client.handle()); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| uint32_t request_byte_capacity = buffer_size; |
| uint8_t* request_bytes = buffer; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client_end.handle()); |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* |
| request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| if (outgoing.ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>*>( |
| 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())); |
| } |
| } |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayNamedComposed>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client.handle()); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| uint32_t request_byte_capacity = buffer_size; |
| uint8_t* request_bytes = buffer; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client_end.handle()); |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* |
| request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| if (outgoing.ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>*>( |
| 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())); |
| } |
| } |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayImport>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>* request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client.handle()); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayImport>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>* request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayImport>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| uint32_t request_byte_capacity = buffer_size; |
| uint8_t* request_bytes = buffer; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client_end.handle()); |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>* request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>* request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayImport>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>* request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>* |
| request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| if (outgoing.ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>*>( |
| 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())); |
| } |
| } |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayLocal>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>* request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client.handle()); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayLocal>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>* request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| uint32_t request_byte_capacity = buffer_size; |
| uint8_t* request_bytes = buffer; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client_end.handle()); |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>* request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>* request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayLocal>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>* request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* |
| request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| if (outgoing.ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>*>( |
| 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())); |
| } |
| } |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::OneWayAnon>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>* request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client.handle()); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::OneWayAnon>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>* request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| uint32_t request_byte_capacity = buffer_size; |
| uint8_t* request_bytes = buffer; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Write(client_end.handle()); |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>* request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>* request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult<::test_protocollayouts::MainProtocol::TwoWayAnon>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>* request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* |
| request) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size())); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| WireResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> client, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* request, |
| zx_time_t deadline) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| request_message(::fidl::internal::AllowUnownedInputRef{}, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>>( |
| client.handle(), bytes_.data(), static_cast<uint32_t>(bytes_.size()), |
| fidl::CallOptions{.deadline = deadline}); |
| SetStatus(outgoing); |
| if (ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>*>( |
| bytes_.data() + 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())); |
| } |
| } |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocollayouts |
| ::fidl::WireUnownedResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| WireUnownedResult( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end, |
| ::fidl::internal::AnyBufferAllocator& allocator, |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>* |
| request) { |
| constexpr uint32_t buffer_size = ::fidl::SyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> allocation = |
| allocator.TryAllocate(buffer_size); |
| if (!allocation.is_ok()) { |
| ::fidl::Status::operator=(allocation.error_value()); |
| return; |
| } |
| uint8_t* buffer = allocation->data; |
| constexpr uint32_t request_byte_capacity = ::fidl::MaxSizeInChannel< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, |
| ::fidl::MessageDirection::kSending>(); |
| uint8_t* request_bytes = buffer; |
| static_assert(buffer_size > request_byte_capacity); |
| uint32_t response_byte_capacity = buffer_size - request_byte_capacity; |
| uint8_t* response_bytes = &buffer[request_byte_capacity]; |
| |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>> |
| request_message(request_bytes, request_byte_capacity, request); |
| auto& outgoing = request_message.GetOutgoingMessage(); |
| outgoing.Call<::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>>( |
| client_end.handle(), response_bytes, response_byte_capacity); |
| bytes_ = response_bytes; |
| if (outgoing.ok()) { |
| auto* raw_response = reinterpret_cast<::fidl::WireResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>*>( |
| 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())); |
| } |
| } |
| ::fidl::Status::operator=(outgoing); |
| } |
| namespace test_protocollayouts { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocollayouts |
| #ifdef __Fuchsia__ |
| |
| ::fidl::Status |
| fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>:: |
| OneWayAnonComposed(::test_protocollayouts_imported::wire:: |
| ComposedProtocolOneWayAnonComposedRequest |
| ComposedProtocolOneWayAnonComposedRequest) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed> |
| _request_object{ComposedProtocolOneWayAnonComposedRequest}; |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| _request_message(::fidl::internal::AllowUnownedInputRef{}, |
| &_request_object); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status |
| fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>:: |
| OneWayNamedComposed( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed> |
| _request_object{ImportTablePayload}; |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| _request_message(::fidl::internal::AllowUnownedInputRef{}, |
| &_request_object); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status |
| fidl::internal::WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>:: |
| OneWayImport(::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport> |
| _request_object{ImportTablePayload}; |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>, |
| ::fidl::internal::ChannelTransport> |
| _request_message(::fidl::internal::AllowUnownedInputRef{}, |
| &_request_object); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status fidl::internal:: |
| WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>::OneWayLocal( |
| ::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal> |
| _request_object{LocalTablePayload}; |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>, |
| ::fidl::internal::ChannelTransport> |
| _request_message(::fidl::internal::AllowUnownedInputRef{}, |
| &_request_object); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status fidl::internal:: |
| WireWeakOnewayClientImpl<::test_protocollayouts::MainProtocol>::OneWayAnon( |
| ::test_protocollayouts::wire::MainProtocolOneWayAnonRequest |
| MainProtocolOneWayAnonRequest) { |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon> |
| _request_object{MainProtocolOneWayAnonRequest}; |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>, |
| ::fidl::internal::ChannelTransport> |
| _request_message(::fidl::internal::AllowUnownedInputRef{}, |
| &_request_object); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonComposed(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedRequest |
| ComposedProtocolTwoWayAnonComposedRequest) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| _request{ComposedProtocolTwoWayAnonComposedRequest}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| _request{ComposedProtocolTwoWayAnonComposedWithErrorRequest}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayNamedComposed( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| _request{ImportUnionPayload}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayNamedComposedWithError( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| _request{ImportTablePayload}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImport> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport> |
| _request{ImportUnionPayload}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayImportWithError( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| _request{ImportTablePayload}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayLocal( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal> |
| _request{LocalUnionPayload}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayLocalWithError( |
| ::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| _request{LocalTablePayload}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable<::test_protocollayouts::MainProtocol::TwoWayAnon> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest |
| MainProtocolTwoWayAnonRequest) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon> |
| _request{MainProtocolTwoWayAnonRequest}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| |
| ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| fidl::internal::WireWeakAsyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonWithError( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest |
| MainProtocolTwoWayAnonWithErrorRequest) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| _request{MainProtocolTwoWayAnonWithErrorRequest}; |
| return ::fidl::internal::WireThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, |
| ::fidl::internal::AllowUnownedInputRef{}, &_request}; |
| } |
| ::fidl::Status fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| OneWayAnonComposed(::test_protocollayouts_imported::wire:: |
| ComposedProtocolOneWayAnonComposedRequest |
| ComposedProtocolOneWayAnonComposedRequest) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed> |
| _request{ComposedProtocolOneWayAnonComposedRequest}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>> |
| _request_message(_allocation->data, _buffer_size, &_request); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| OneWayNamedComposed( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed> |
| _request{ImportTablePayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>> |
| _request_message(_allocation->data, _buffer_size, &_request); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| OneWayImport(::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayImport>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport> |
| _request{ImportTablePayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>> |
| _request_message(_allocation->data, _buffer_size, &_request); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| OneWayLocal( |
| ::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal> |
| _request{LocalTablePayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>> |
| _request_message(_allocation->data, _buffer_size, &_request); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::Status fidl::internal::WireWeakOnewayBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| OneWayAnon(::test_protocollayouts::wire::MainProtocolOneWayAnonRequest |
| MainProtocolOneWayAnonRequest) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon> |
| _request{MainProtocolOneWayAnonRequest}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>> |
| _request_message(_allocation->data, _buffer_size, &_request); |
| return _client_base()->SendOneWay(_request_message.GetOutgoingMessage()); |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonComposed(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedRequest |
| ComposedProtocolTwoWayAnonComposedRequest) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| _request{ComposedProtocolTwoWayAnonComposedRequest}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| _request{ComposedProtocolTwoWayAnonComposedWithErrorRequest}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayNamedComposed( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| _request{ImportUnionPayload}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayNamedComposedWithError( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| _request{ImportTablePayload}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImport> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport> |
| _request{ImportUnionPayload}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayImportWithError( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| _request{ImportTablePayload}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayLocal( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal> |
| _request{LocalUnionPayload}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayLocalWithError( |
| ::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| _request{LocalTablePayload}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest |
| MainProtocolTwoWayAnonRequest) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon> |
| _request{MainProtocolTwoWayAnonRequest}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| fidl::internal::WireWeakAsyncBufferClientImpl< |
| ::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonWithError( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest |
| MainProtocolTwoWayAnonWithErrorRequest) { |
| constexpr uint32_t _buffer_size = |
| ::fidl::AsyncClientMethodBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(); |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| _request{MainProtocolTwoWayAnonWithErrorRequest}; |
| return ::fidl::internal::WireBufferThenable< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>{ |
| _client_base(), ::fidl::WriteOptions{}, _allocator(), _buffer_size, |
| &_request}; |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonComposed(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedRequest |
| ComposedProtocolTwoWayAnonComposedRequest) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| _request{ComposedProtocolTwoWayAnonComposedRequest}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest |
| ComposedProtocolTwoWayAnonComposedWithErrorRequest) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| _request{ComposedProtocolTwoWayAnonComposedWithErrorRequest}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayNamedComposed( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| _request{ImportUnionPayload}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayNamedComposedWithError( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| _request{ImportTablePayload}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImport> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayImport(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport> |
| _request{ImportUnionPayload}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayImportWithError( |
| ::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| _request{ImportTablePayload}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocal> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayLocal( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal> |
| _request{LocalUnionPayload}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayLocalWithError( |
| ::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| _request{LocalTablePayload}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnon> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnon(::test_protocollayouts::wire::MainProtocolTwoWayAnonRequest |
| MainProtocolTwoWayAnonRequest) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon> |
| _request{MainProtocolTwoWayAnonRequest}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| |
| ::fidl::WireResult<::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| fidl::internal::WireWeakSyncClientImpl<::test_protocollayouts::MainProtocol>:: |
| TwoWayAnonWithError( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorRequest |
| MainProtocolTwoWayAnonWithErrorRequest) { |
| return _client_base()->MakeSyncCallWith( |
| [&](std::shared_ptr<::fidl::internal::AnyTransport> _transport) { |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| _request{MainProtocolTwoWayAnonWithErrorRequest}; |
| return ::fidl::WireResult< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol>( |
| _transport->get<::fidl::internal::ChannelTransport>()), |
| &_request); |
| }); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| ::fidl::Status fidl:: |
| WireSyncEventHandler<::test_protocollayouts::MainProtocol>::HandleOneEvent( |
| ::fidl::UnownedClientEnd<::test_protocollayouts::MainProtocol> |
| client_end) { |
| zx_status_t status = client_end.channel()->wait_one( |
| ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED, ::zx::time::infinite(), |
| nullptr); |
| if (status != ZX_OK) { |
| return ::fidl::Status::TransportError( |
| status, ::fidl::internal::kErrorWaitOneFailed); |
| } |
| constexpr uint32_t kHandleAllocSize = ([]() constexpr { |
| uint32_t x = 0; |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>>:: |
| kMaxNumHandles >= x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>>:: |
| kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>>:: |
| kMaxNumHandles >= x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>>:: |
| kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>>:: |
| kMaxNumHandles >= x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>>:: |
| kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>>:: |
| kMaxNumHandles >= x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>>:: |
| kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>>::kMaxNumHandles >= |
| x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>>::kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>>:: |
| kMaxNumHandles >= x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>>:: |
| kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>>::kMaxNumHandles >= |
| x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>>::kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>>:: |
| kMaxNumHandles >= x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>>:: |
| kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>>::kMaxNumHandles >= |
| x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>>::kMaxNumHandles; |
| } |
| if (::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>>:: |
| kMaxNumHandles >= x) { |
| x = ::fidl::TypeTraits<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>>:: |
| kMaxNumHandles; |
| } |
| if (x > ZX_CHANNEL_MAX_MSG_HANDLES) { |
| x = ZX_CHANNEL_MAX_MSG_HANDLES; |
| } |
| return x; |
| })(); |
| static_assert(kHandleAllocSize <= ZX_CHANNEL_MAX_MSG_HANDLES); |
| ::fidl::internal::BoxedMessageBuffer<ZX_CHANNEL_MAX_MSG_BYTES> read_storage; |
| std::array<zx_handle_t, kHandleAllocSize> read_handles; |
| // TODO(fxbug.dev/85734) Remove this channel-specific allocation. |
| std::array<fidl_channel_handle_metadata_t, kHandleAllocSize> |
| read_handle_metadata; |
| ::fidl::IncomingMessage msg = ::fidl::MessageRead( |
| zx::unowned_channel(client_end.handle()), read_storage.view(), |
| read_handles.data(), read_handle_metadata.data(), kHandleAllocSize, |
| ReadOptions{.discardable = true}); |
| if (msg.status() == ZX_ERR_BUFFER_TOO_SMALL) { |
| // Message size is unexpectedly larger than calculated. |
| // This can only be due to a newer version of the protocol defining a new |
| // event, whose size exceeds the maximum of known events in the current |
| // protocol. |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_BUFFER_TOO_SMALL, |
| ::fidl::internal::kErrorSyncEventBufferTooSmall); |
| } |
| if (!msg.ok()) { |
| return msg; |
| } |
| fidl_message_header_t* hdr = msg.header(); |
| switch (hdr->ordinal) { |
| case ::test_protocollayouts::kMainProtocol_OnAnonComposed_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnAnonComposed(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts:: |
| kMainProtocol_OnAnonComposedWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnAnonComposedWithError(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts::kMainProtocol_OnNamedComposed_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnNamedComposed(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts:: |
| kMainProtocol_OnNamedComposedWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnNamedComposedWithError(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts::kMainProtocol_OnImport_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnImport(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts::kMainProtocol_OnImportWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnImportWithError(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts::kMainProtocol_OnLocal_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnLocal(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts::kMainProtocol_OnLocalWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnLocalWithError(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts::kMainProtocol_OnAnon_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnAnon(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| case ::test_protocollayouts::kMainProtocol_OnAnonWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>> |
| decoded{::std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::Status(decoded); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| got_transitional_ = false; |
| OnAnonWithError(primary); |
| if (got_transitional_) { |
| return ::fidl::Status::UnexpectedMessage( |
| ZX_ERR_NOT_SUPPORTED, |
| ::fidl::internal::kErrorSyncEventUnhandledTransitionalEvent); |
| } |
| return ::fidl::Status::Ok(); |
| } |
| default: { |
| return ::fidl::Status::UnknownOrdinal(); |
| } |
| } |
| } |
| |
| std::optional<::fidl::UnbindInfo> fidl::internal:: |
| WireEventDispatcher<::test_protocollayouts::MainProtocol>::DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| ::fidl::internal::IncomingTransportContext transport_context) { |
| switch (msg.header()->ordinal) { |
| case ::test_protocollayouts::kMainProtocol_OnAnonComposed_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnAnonComposed(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts:: |
| kMainProtocol_OnAnonComposedWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnAnonComposedWithError(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts::kMainProtocol_OnNamedComposed_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnNamedComposed(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts:: |
| kMainProtocol_OnNamedComposedWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnNamedComposedWithError(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts::kMainProtocol_OnImport_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnImport(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts::kMainProtocol_OnImportWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnImportWithError(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts::kMainProtocol_OnLocal_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnLocal(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts::kMainProtocol_OnLocalWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnLocalWithError(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts::kMainProtocol_OnAnon_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnAnon(primary); |
| } |
| return std::nullopt; |
| } |
| case ::test_protocollayouts::kMainProtocol_OnAnonWithError_Ordinal: { |
| ::fidl::unstable::DecodedMessage<::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>> |
| decoded{std::move(msg)}; |
| if (!decoded.ok()) { |
| return ::fidl::UnbindInfo{decoded}; |
| } |
| if (event_handler()) { |
| auto* primary = &decoded.PrimaryObject()->body; |
| event_handler()->OnAnonWithError(primary); |
| } |
| return std::nullopt; |
| } |
| default: |
| break; |
| } |
| return ::fidl::UnbindInfo::UnknownOrdinal(); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| constexpr ::fidl::internal::MethodEntry fidl::internal::WireServerDispatcher< |
| ::test_protocollayouts::MainProtocol>::entries_[] = { |
| { |
| ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->OneWayAnonComposed(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayAnonComposed(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayAnonComposedWithError_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol:: |
| TwoWayAnonComposedWithError>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter<::test_protocollayouts::MainProtocol:: |
| TwoWayAnonComposedWithError>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayAnonComposedWithError(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->OneWayNamedComposed(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayNamedComposed(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayNamedComposedWithError_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol:: |
| TwoWayNamedComposedWithError>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol:: |
| TwoWayNamedComposedWithError>::Sync completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayNamedComposedWithError(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_OneWayImport_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::OneWayImport>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->OneWayImport(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayImport(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayImportWithError(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_OneWayLocal_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->OneWayLocal(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayLocal(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayLocalWithError(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_OneWayAnon_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->OneWayAnon(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayAnon(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| { |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal, |
| [](void* interface, ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::unstable::DecodedMessage< |
| ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>> |
| decoded{std::move(msg)}; |
| if (unlikely(!decoded.ok())) { |
| return decoded.status(); |
| } |
| auto* primary = &decoded.PrimaryObject()->body; |
| ::fidl::internal::WireCompleter< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::Sync |
| completer(txn); |
| reinterpret_cast< |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>*>( |
| interface) |
| ->TwoWayAnonWithError(primary, completer); |
| return ZX_OK; |
| }, |
| }, |
| }; |
| |
| const ::fidl::internal::MethodEntry* fidl::internal::WireServerDispatcher< |
| ::test_protocollayouts::MainProtocol>::entries_end_ = &entries_[15]; |
| |
| ::fidl::DispatchResult fidl::internal:: |
| WireServerDispatcher<::test_protocollayouts::MainProtocol>::TryDispatch( |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>* impl, |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| return ::fidl::internal::TryDispatch(impl, msg, std::move(transport_context), |
| txn, entries_, entries_end_); |
| } |
| |
| void fidl::internal:: |
| WireServerDispatcher<::test_protocollayouts::MainProtocol>::Dispatch( |
| ::fidl::WireServer<::test_protocollayouts::MainProtocol>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn) { |
| ::fidl::internal::Dispatch(impl, msg, std::move(transport_context), txn, |
| entries_, entries_end_); |
| } |
| void fidl::WireServer<::test_protocollayouts::MainProtocol>::dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) { |
| ::fidl::internal::WireServerDispatcher<::test_protocollayouts::MainProtocol>:: |
| Dispatch(this, std::move(msg), std::move(transport_context), txn); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>:: |
| Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedResponse |
| ComposedProtocolTwoWayAnonComposedResponse) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| _response{ComposedProtocolTwoWayAnonComposedResponse}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>:: |
| Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedResponse |
| ComposedProtocolTwoWayAnonComposedResponse) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed> |
| _response{ComposedProtocolTwoWayAnonComposedResponse}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| ReplySuccess(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse) { |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = |
| std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse); |
| |
| return Reply( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse( |
| ::fidl::ObjectView< |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr( |
| std::move(error))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError> |
| _response{result}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| ReplySuccess(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse) { |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse _response = |
| std::move(ComposedProtocolTwoWayAnonComposedWithErrorResponse); |
| |
| return Reply( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResult::WithResponse( |
| ::fidl::ObjectView< |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResponse>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayAnonComposedWithErrorResult::WithErr( |
| std::move(error))); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>:: |
| Reply(::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| _response{ImportTablePayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>:: |
| Reply(::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed> |
| _response{ImportTablePayload}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayNamedComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::test_protocollayouts_imported::wire::ImportUnionPayload _response = |
| std::move(ImportUnionPayload); |
| |
| return Reply( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse( |
| ::fidl::ObjectView< |
| ::test_protocollayouts_imported::wire::ImportUnionPayload>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr( |
| std::move(error))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayNamedComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError> |
| _response{result}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::test_protocollayouts_imported::wire::ImportUnionPayload _response = |
| std::move(ImportUnionPayload); |
| |
| return Reply( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayNamedComposedWithErrorResult::WithResponse( |
| ::fidl::ObjectView< |
| ::test_protocollayouts_imported::wire::ImportUnionPayload>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply(::test_protocollayouts_imported::wire:: |
| ComposedProtocolTwoWayNamedComposedWithErrorResult::WithErr( |
| std::move(error))); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>:: |
| Reply(::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport> |
| _response{ImportTablePayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>:: |
| Reply(::test_protocollayouts_imported::wire::ImportTablePayload |
| ImportTablePayload) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport> |
| _response{ImportTablePayload}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| Reply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::test_protocollayouts_imported::wire::ImportUnionPayload _response = |
| std::move(ImportUnionPayload); |
| |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult:: |
| WithResponse( |
| ::fidl::ObjectView< |
| ::test_protocollayouts_imported::wire::ImportUnionPayload>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult:: |
| WithErr(std::move(error))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| Reply(::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError> |
| _response{result}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| ReplySuccess(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::test_protocollayouts_imported::wire::ImportUnionPayload _response = |
| std::move(ImportUnionPayload); |
| |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult:: |
| WithResponse( |
| ::fidl::ObjectView< |
| ::test_protocollayouts_imported::wire::ImportUnionPayload>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayImportWithErrorResult:: |
| WithErr(std::move(error))); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal:: |
| WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayLocal>::Reply( |
| ::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal> |
| _response{LocalTablePayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>:: |
| Reply(::test_protocollayouts::wire::LocalTablePayload LocalTablePayload) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal> |
| _response{LocalTablePayload}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| Reply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| ReplySuccess( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| ::test_protocollayouts::wire::LocalUnionPayload _response = |
| std::move(LocalUnionPayload); |
| |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult:: |
| WithResponse(::fidl::ObjectView< |
| ::test_protocollayouts::wire::LocalUnionPayload>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult:: |
| WithErr(std::move(error))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| Reply(::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError> |
| _response{result}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| ReplySuccess( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| ::test_protocollayouts::wire::LocalUnionPayload _response = |
| std::move(LocalUnionPayload); |
| |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult:: |
| WithResponse(::fidl::ObjectView< |
| ::test_protocollayouts::wire::LocalUnionPayload>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayLocalWithErrorResult:: |
| WithErr(std::move(error))); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal:: |
| WireCompleterImpl<::test_protocollayouts::MainProtocol::TwoWayAnon>::Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse |
| MainProtocolTwoWayAnonResponse) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon> |
| _response{MainProtocolTwoWayAnonResponse}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>:: |
| Reply(::test_protocollayouts::wire::MainProtocolTwoWayAnonResponse |
| MainProtocolTwoWayAnonResponse) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon> |
| _response{MainProtocolTwoWayAnonResponse}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| Reply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| ReplySuccess( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse |
| MainProtocolTwoWayAnonWithErrorResponse) { |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse |
| _response = std::move(MainProtocolTwoWayAnonWithErrorResponse); |
| |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult:: |
| WithResponse( |
| ::fidl::ObjectView<::test_protocollayouts::wire:: |
| MainProtocolTwoWayAnonWithErrorResponse>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult:: |
| WithErr(std::move(error))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| Reply(::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError> |
| _response{result}; |
| constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| ::fidl::OutgoingMessage _failure{_allocation.error_value()}; |
| return _core()->SendReply(&_failure, |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _core()->SendReply(&_response_message.GetOutgoingMessage(), |
| ::fidl::internal::OutgoingTransportContext()); |
| } |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| ReplySuccess( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse |
| MainProtocolTwoWayAnonWithErrorResponse) { |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResponse |
| _response = std::move(MainProtocolTwoWayAnonWithErrorResponse); |
| |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult:: |
| WithResponse( |
| ::fidl::ObjectView<::test_protocollayouts::wire:: |
| MainProtocolTwoWayAnonWithErrorResponse>:: |
| FromExternal(&_response))); |
| } |
| |
| void fidl::internal::WireBufferCompleterImpl< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>:: |
| ReplyError(uint32_t error) { |
| return Reply( |
| ::test_protocollayouts::wire::MainProtocolTwoWayAnonWithErrorResult:: |
| WithErr(std::move(error))); |
| } |
| #endif // __Fuchsia__ |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnonComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OneWayAnonComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonComposedWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonComposedWithError_Ordinal, |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayAnonComposedWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OnAnonComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnAnonComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_OnAnonComposedWithError_Ordinal, |
| ::test_protocollayouts:: |
| kMainProtocol_OnAnonComposedWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayNamedComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OneWayNamedComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayNamedComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayNamedComposedWithError_Ordinal, |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayNamedComposedWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayNamedComposedWithError_Ordinal, |
| ::test_protocollayouts:: |
| kMainProtocol_TwoWayNamedComposedWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OnNamedComposed_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnNamedComposed_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_OnNamedComposedWithError_Ordinal, |
| ::test_protocollayouts:: |
| kMainProtocol_OnNamedComposedWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayImport>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OneWayImport_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OneWayImport_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayImport_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImport>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_TwoWayImport_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayImport_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayImportWithError>:: |
| _InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayImportWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OnImport_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnImport_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_OnImportWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnImportWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayLocal>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OneWayLocal_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OneWayLocal_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayLocal_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocal>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_TwoWayLocal_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayLocal_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayLocalWithError>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayLocalWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OnLocal_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnLocal_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_OnLocalWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnLocalWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::OneWayAnon>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OneWayAnon_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OneWayAnon_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnon_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnon>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_TwoWayAnon_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnon_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalRequest< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalResponse< |
| ::test_protocollayouts::MainProtocol::TwoWayAnonWithError>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_TwoWayAnonWithError_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OnAnon_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnAnon_DynamicFlags); |
| } |
| |
| void ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>::_InitHeader() { |
| ::fidl::InitTxnHeader( |
| &header, 0, ::test_protocollayouts::kMainProtocol_OnAnonWithError_Ordinal, |
| ::test_protocollayouts::kMainProtocol_OnAnonWithError_DynamicFlags); |
| } |
| |
| #ifdef __Fuchsia__ |
| |
| fidl::Status fidl::internal:: |
| WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnAnonComposed( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedRequest |
| ComposedProtocolOnAnonComposedRequest) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed> |
| _response{ComposedProtocolOnAnonComposedRequest}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal::WireWeakBufferEventSender< |
| ::test_protocollayouts::MainProtocol>:: |
| OnAnonComposed(::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedRequest |
| ComposedProtocolOnAnonComposedRequest) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed> |
| _response{ComposedProtocolOnAnonComposedRequest}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireEventSender<::test_protocollayouts::MainProtocol>::OnAnonComposed( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedRequest |
| ComposedProtocolOnAnonComposedRequest) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed> |
| _response{ComposedProtocolOnAnonComposedRequest}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnAnonComposed( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedRequest |
| ComposedProtocolOnAnonComposedRequest) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed> |
| _response{ComposedProtocolOnAnonComposedRequest}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>:: |
| OnAnonComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal::WireWeakBufferEventSender< |
| ::test_protocollayouts::MainProtocol>:: |
| OnAnonComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedWithErrorResult result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status |
| fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>:: |
| OnAnonComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>:: |
| OnAnonComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnAnonComposedWithErrorResult result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnNamedComposed( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed> |
| _response{ImportUnionPayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal::WireWeakBufferEventSender< |
| ::test_protocollayouts::MainProtocol>:: |
| OnNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed> |
| _response{ImportUnionPayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireEventSender<::test_protocollayouts::MainProtocol>::OnNamedComposed( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed> |
| _response{ImportUnionPayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>:: |
| OnNamedComposed(::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed> |
| _response{ImportUnionPayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposed>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>:: |
| OnNamedComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnNamedComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal::WireWeakBufferEventSender< |
| ::test_protocollayouts::MainProtocol>:: |
| OnNamedComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnNamedComposedWithErrorResult result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status |
| fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>:: |
| OnNamedComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnNamedComposedWithErrorResult result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>:: |
| OnNamedComposedWithError( |
| ::test_protocollayouts_imported::wire:: |
| ComposedProtocolOnNamedComposedWithErrorResult result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnNamedComposedWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnImport( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport> |
| _response{ImportUnionPayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnImport( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnImport>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport> |
| _response{ImportUnionPayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status |
| fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnImport( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport> |
| _response{ImportUnionPayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnImport( |
| ::test_protocollayouts_imported::wire::ImportUnionPayload |
| ImportUnionPayload) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnImport>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport> |
| _response{ImportUnionPayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImport>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireWeakEventSender<::test_protocollayouts::MainProtocol>:: |
| OnImportWithError( |
| ::test_protocollayouts::wire::MainProtocolOnImportWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal::WireWeakBufferEventSender< |
| ::test_protocollayouts::MainProtocol>:: |
| OnImportWithError( |
| ::test_protocollayouts::wire::MainProtocolOnImportWithErrorResult |
| result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireEventSender<::test_protocollayouts::MainProtocol>::OnImportWithError( |
| ::test_protocollayouts::wire::MainProtocolOnImportWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>:: |
| OnImportWithError( |
| ::test_protocollayouts::wire::MainProtocolOnImportWithErrorResult |
| result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnImportWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnLocal( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal> |
| _response{LocalUnionPayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnLocal( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnLocal>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal> |
| _response{LocalUnionPayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status |
| fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnLocal( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal> |
| _response{LocalUnionPayload}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnLocal( |
| ::test_protocollayouts::wire::LocalUnionPayload LocalUnionPayload) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnLocal>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal> |
| _response{LocalUnionPayload}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocal>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnLocalWithError( |
| ::test_protocollayouts::wire::MainProtocolOnLocalWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal::WireWeakBufferEventSender< |
| ::test_protocollayouts::MainProtocol>:: |
| OnLocalWithError( |
| ::test_protocollayouts::wire::MainProtocolOnLocalWithErrorResult |
| result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireEventSender<::test_protocollayouts::MainProtocol>::OnLocalWithError( |
| ::test_protocollayouts::wire::MainProtocolOnLocalWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>:: |
| OnLocalWithError( |
| ::test_protocollayouts::wire::MainProtocolOnLocalWithErrorResult |
| result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnLocalWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnAnon( |
| ::test_protocollayouts::wire::MainProtocolOnAnonRequest |
| MainProtocolOnAnonRequest) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon> |
| _response{MainProtocolOnAnonRequest}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakBufferEventSender<::test_protocollayouts::MainProtocol>::OnAnon( |
| ::test_protocollayouts::wire::MainProtocolOnAnonRequest |
| MainProtocolOnAnonRequest) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnon>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon> |
| _response{MainProtocolOnAnonRequest}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status |
| fidl::internal::WireEventSender<::test_protocollayouts::MainProtocol>::OnAnon( |
| ::test_protocollayouts::wire::MainProtocolOnAnonRequest |
| MainProtocolOnAnonRequest) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon> |
| _response{MainProtocolOnAnonRequest}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireBufferEventSender<::test_protocollayouts::MainProtocol>::OnAnon( |
| ::test_protocollayouts::wire::MainProtocolOnAnonRequest |
| MainProtocolOnAnonRequest) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnon>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon> |
| _response{MainProtocolOnAnonRequest}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnon>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status fidl::internal:: |
| WireWeakEventSender<::test_protocollayouts::MainProtocol>::OnAnonWithError( |
| ::test_protocollayouts::wire::MainProtocolOnAnonWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal::WireWeakBufferEventSender< |
| ::test_protocollayouts::MainProtocol>:: |
| OnAnonWithError( |
| ::test_protocollayouts::wire::MainProtocolOnAnonWithErrorResult |
| result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| _inner().HandleSendError(_allocation.error_value()); |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| return _inner().SendEvent(_response_message.GetOutgoingMessage()); |
| } |
| |
| fidl::Status fidl::internal:: |
| WireEventSender<::test_protocollayouts::MainProtocol>::OnAnonWithError( |
| ::test_protocollayouts::wire::MainProtocolOnAnonWithErrorResult |
| result) { |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError> |
| _response{result}; |
| FIDL_INTERNAL_DISABLE_AUTO_VAR_INIT |
| ::fidl::unstable::OwnedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message{::fidl::internal::AllowUnownedInputRef{}, &_response}; |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| fidl::Status |
| fidl::internal::WireBufferEventSender<::test_protocollayouts::MainProtocol>:: |
| OnAnonWithError( |
| ::test_protocollayouts::wire::MainProtocolOnAnonWithErrorResult |
| result) { |
| constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>(); |
| ::fitx::result<::fidl::Error, ::fidl::BufferSpan> _allocation = |
| _allocator().TryAllocate(_buffer_size); |
| if (!_allocation.is_ok()) { |
| return _allocation.error_value(); |
| } |
| |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError> |
| _response{result}; |
| ::fidl::unstable::UnownedEncodedMessage< |
| ::fidl::internal::TransactionalEvent< |
| ::test_protocollayouts::MainProtocol::OnAnonWithError>, |
| ::fidl::internal::ChannelTransport> |
| _response_message(_allocation->data, _buffer_size, &_response); |
| auto& _message = _response_message.GetOutgoingMessage(); |
| _message.Write(_transport()); |
| return ::fidl::Status{_message}; |
| } |
| |
| #endif // __Fuchsia__ |
