| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <union.test.json.llcpp.h> |
| |
| #include <memory> |
| |
| namespace llcpp { |
| |
| namespace fidl { |
| namespace test { |
| namespace json { |
| |
| void ::llcpp::fidl::test::json::Union::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(Union) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(Union, ordinal_) == offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(Union, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::StrictUnion::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(StrictUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(StrictUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(StrictUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::StrictSimpleXUnion:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(StrictSimpleXUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(StrictSimpleXUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(StrictSimpleXUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::StrictFoo::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(StrictFoo) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(StrictFoo, ordinal_) == offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(StrictFoo, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::StrictBoundedXUnion:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(StrictBoundedXUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(StrictBoundedXUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(StrictBoundedXUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::ReverseOrdinalUnion:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ReverseOrdinalUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ReverseOrdinalUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ReverseOrdinalUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::StrictPizzaOrPasta:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(StrictPizzaOrPasta) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(StrictPizzaOrPasta, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(StrictPizzaOrPasta, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::PizzaOrPasta::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(PizzaOrPasta) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(PizzaOrPasta, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(PizzaOrPasta, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| auto ::llcpp::fidl::test::json::FlexiblePizzaOrPasta::which() const -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kPizza: |
| case Ordinal::kPasta: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::FlexiblePizzaOrPasta:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(FlexiblePizzaOrPasta) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(FlexiblePizzaOrPasta, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(FlexiblePizzaOrPasta, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::ExplicitPizzaOrPasta:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ExplicitPizzaOrPasta) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ExplicitPizzaOrPasta, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ExplicitPizzaOrPasta, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| auto ::llcpp::fidl::test::json::OlderSimpleUnion::which() const -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kI: |
| case Ordinal::kF: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::OlderSimpleUnion:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(OlderSimpleUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(OlderSimpleUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(OlderSimpleUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] constexpr uint64_t |
| kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_Ordinal = |
| 0x68bfe80f00000000lu; |
| [[maybe_unused]] constexpr uint64_t |
| kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_GenOrdinal = |
| 0x728fedeed6ef99dalu; |
| extern "C" const fidl_type_t |
| v1_fidl_test_json_TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedRequestTable; |
| extern "C" const fidl_type_t |
| v1_fidl_test_json_TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedResponseTable; |
| [[maybe_unused]] constexpr uint64_t |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_Ordinal = |
| 0x176e085800000000lu; |
| [[maybe_unused]] constexpr uint64_t |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_GenOrdinal = |
| 0xfd2ba0109faffe3lu; |
| extern "C" const fidl_type_t |
| v1_fidl_test_json_TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedRequestTable; |
| extern "C" const fidl_type_t |
| v1_fidl_test_json_TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedResponseTable; |
| |
| } // namespace |
| template <> |
| TestProtocol::ResultOf::StrictXUnionHenceResponseMayBeStackAllocated_Impl< |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponse>:: |
| StrictXUnionHenceResponseMayBeStackAllocated_Impl( |
| ::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize< |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest, |
| ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes( |
| _write_bytes, _kWriteAllocSize, |
| sizeof(StrictXUnionHenceResponseMayBeStackAllocatedRequest)); |
| ::fidl::DecodedMessage<StrictXUnionHenceResponseMayBeStackAllocatedRequest> |
| _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| TestProtocol::InPlace::StrictXUnionHenceResponseMayBeStackAllocated( |
| std::move(_client_end), Super::response_buffer())); |
| } |
| |
| TestProtocol::ResultOf::StrictXUnionHenceResponseMayBeStackAllocated |
| TestProtocol::SyncClient::StrictXUnionHenceResponseMayBeStackAllocated() { |
| return ResultOf::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::zx::unowned_channel(this->channel_)); |
| } |
| |
| TestProtocol::ResultOf::StrictXUnionHenceResponseMayBeStackAllocated |
| TestProtocol::Call::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::zx::unowned_channel _client_end) { |
| return ResultOf::StrictXUnionHenceResponseMayBeStackAllocated( |
| std::move(_client_end)); |
| } |
| |
| template <> |
| TestProtocol::UnownedResultOf:: |
| StrictXUnionHenceResponseMayBeStackAllocated_Impl< |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponse>:: |
| StrictXUnionHenceResponseMayBeStackAllocated_Impl( |
| ::zx::unowned_channel _client_end, |
| ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof( |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest::PrimarySize); |
| _request_buffer.set_actual( |
| sizeof(StrictXUnionHenceResponseMayBeStackAllocatedRequest)); |
| ::fidl::DecodedMessage<StrictXUnionHenceResponseMayBeStackAllocatedRequest> |
| _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| TestProtocol::InPlace::StrictXUnionHenceResponseMayBeStackAllocated( |
| std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| TestProtocol::UnownedResultOf::StrictXUnionHenceResponseMayBeStackAllocated |
| TestProtocol::SyncClient::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| TestProtocol::UnownedResultOf::StrictXUnionHenceResponseMayBeStackAllocated |
| TestProtocol::Call::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::StrictXUnionHenceResponseMayBeStackAllocated( |
| std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult< |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponse> |
| TestProtocol::InPlace::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = |
| sizeof(StrictXUnionHenceResponseMayBeStackAllocatedRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<StrictXUnionHenceResponseMayBeStackAllocatedRequest> |
| params(std::move(_request_buffer)); |
| TestProtocol::SetTransactionHeaderFor:: |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult< |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponse>:: |
| FromFailure(std::move(_encode_request_result)); |
| } |
| auto _call_result = |
| ::fidl::Call<StrictXUnionHenceResponseMayBeStackAllocatedRequest, |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), |
| std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult< |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponse>:: |
| FromFailure(std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| TestProtocol::ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated_Impl< |
| TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated_Impl( |
| ::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize< |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest, |
| ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| uint8_t* _write_bytes = _write_bytes_array.view().data(); |
| memset(_write_bytes, 0, |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes( |
| _write_bytes, _kWriteAllocSize, |
| sizeof(FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest)); |
| ::fidl::DecodedMessage<FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest> |
| _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| TestProtocol::InPlace::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| std::move(_client_end), Super::response_buffer())); |
| } |
| |
| TestProtocol::ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated |
| TestProtocol::SyncClient::FlexibleXUnionHenceResponseMustBeHeapAllocated() { |
| return ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::zx::unowned_channel(this->channel_)); |
| } |
| |
| TestProtocol::ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated |
| TestProtocol::Call::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::zx::unowned_channel _client_end) { |
| return ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| std::move(_client_end)); |
| } |
| |
| template <> |
| TestProtocol::UnownedResultOf:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated_Impl< |
| TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated_Impl( |
| ::zx::unowned_channel _client_end, |
| ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof( |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::PrimarySize); |
| _request_buffer.set_actual( |
| sizeof(FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest)); |
| ::fidl::DecodedMessage<FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest> |
| _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| TestProtocol::InPlace::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| TestProtocol::UnownedResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated |
| TestProtocol::SyncClient::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| TestProtocol::UnownedResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated |
| TestProtocol::Call::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult< |
| TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse> |
| TestProtocol::InPlace::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = |
| sizeof(FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest> |
| params(std::move(_request_buffer)); |
| TestProtocol::SetTransactionHeaderFor:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult< |
| TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>:: |
| FromFailure(std::move(_encode_request_result)); |
| } |
| auto _call_result = |
| ::fidl::Call<FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest, |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), |
| std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult< |
| TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>:: |
| FromFailure(std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| bool TestProtocol::TryDispatch(Interface* impl, fidl_msg_t* msg, |
| ::fidl::Transaction* txn) { |
| if (msg->num_bytes < sizeof(fidl_message_header_t)) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| fidl_message_header_t* hdr = |
| reinterpret_cast<fidl_message_header_t*>(msg->bytes); |
| zx_status_t status = fidl_validate_txn_header(hdr); |
| if (status != ZX_OK) { |
| txn->Close(status); |
| return true; |
| } |
| switch (hdr->ordinal) { |
| case kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_Ordinal: |
| case kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_GenOrdinal: { |
| auto result = |
| ::fidl::DecodeAs<StrictXUnionHenceResponseMayBeStackAllocatedRequest>( |
| msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->StrictXUnionHenceResponseMayBeStackAllocated( |
| Interface::StrictXUnionHenceResponseMayBeStackAllocatedCompleter:: |
| Sync(txn)); |
| return true; |
| } |
| case kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_Ordinal: |
| case kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_GenOrdinal: { |
| auto result = ::fidl::DecodeAs< |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| Interface::FlexibleXUnionHenceResponseMustBeHeapAllocatedCompleter:: |
| Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool TestProtocol::Dispatch(Interface* impl, fidl_msg_t* msg, |
| ::fidl::Transaction* txn) { |
| bool found = TryDispatch(impl, msg, txn); |
| if (!found) { |
| zx_handle_close_many(msg->handles, msg->num_handles); |
| txn->Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| return found; |
| } |
| |
| void TestProtocol::Interface:: |
| StrictXUnionHenceResponseMayBeStackAllocatedCompleterBase::Reply( |
| ::llcpp::fidl::test::json::StrictBoundedXUnion xu) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize< |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse, |
| ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize]; |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse _response = {}; |
| TestProtocol::SetTransactionHeaderFor:: |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse( |
| ::fidl::DecodedMessage< |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse>( |
| ::fidl::BytePart( |
| reinterpret_cast<uint8_t*>(&_response), |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse:: |
| PrimarySize, |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse:: |
| PrimarySize))); |
| _response.xu = std::move(xu); |
| auto _linearize_result = ::fidl::Linearize( |
| &_response, ::fidl::BytePart(_write_bytes, _kWriteAllocSize)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void TestProtocol::Interface:: |
| StrictXUnionHenceResponseMayBeStackAllocatedCompleterBase::Reply( |
| ::fidl::BytePart _buffer, |
| ::llcpp::fidl::test::json::StrictBoundedXUnion xu) { |
| if (_buffer.capacity() < |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse _response = {}; |
| TestProtocol::SetTransactionHeaderFor:: |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse( |
| ::fidl::DecodedMessage< |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse>( |
| ::fidl::BytePart( |
| reinterpret_cast<uint8_t*>(&_response), |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse:: |
| PrimarySize, |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse:: |
| PrimarySize))); |
| _response.xu = std::move(xu); |
| auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void TestProtocol::Interface:: |
| StrictXUnionHenceResponseMayBeStackAllocatedCompleterBase::Reply( |
| ::fidl::DecodedMessage< |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse> |
| params) { |
| TestProtocol::SetTransactionHeaderFor:: |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| void TestProtocol::Interface:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedCompleterBase::Reply( |
| ::llcpp::fidl::test::json::OlderSimpleUnion xu) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize< |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse, |
| ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr( |
| new uint8_t[_kWriteAllocSize]); |
| uint8_t* _write_bytes = _write_bytes_unique_ptr.get(); |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse _response = {}; |
| TestProtocol::SetTransactionHeaderFor:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse( |
| ::fidl::DecodedMessage< |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>( |
| ::fidl::BytePart( |
| reinterpret_cast<uint8_t*>(&_response), |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse:: |
| PrimarySize, |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse:: |
| PrimarySize))); |
| _response.xu = std::move(xu); |
| auto _linearize_result = ::fidl::Linearize( |
| &_response, ::fidl::BytePart(_write_bytes, _kWriteAllocSize)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void TestProtocol::Interface:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedCompleterBase::Reply( |
| ::fidl::BytePart _buffer, |
| ::llcpp::fidl::test::json::OlderSimpleUnion xu) { |
| if (_buffer.capacity() < |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse _response = {}; |
| TestProtocol::SetTransactionHeaderFor:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse( |
| ::fidl::DecodedMessage< |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>( |
| ::fidl::BytePart( |
| reinterpret_cast<uint8_t*>(&_response), |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse:: |
| PrimarySize, |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse:: |
| PrimarySize))); |
| _response.xu = std::move(xu); |
| auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CompleterBase::SendReply(std::move(_linearize_result.message)); |
| } |
| |
| void TestProtocol::Interface:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedCompleterBase::Reply( |
| ::fidl::DecodedMessage< |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse> |
| params) { |
| TestProtocol::SetTransactionHeaderFor:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| void TestProtocol::SetTransactionHeaderFor:: |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest( |
| const ::fidl::DecodedMessage< |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedRequest>& |
| _msg) { |
| fidl_init_txn_header( |
| &_msg.message()->_hdr, 0, |
| kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void TestProtocol::SetTransactionHeaderFor:: |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse( |
| const ::fidl::DecodedMessage< |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponse>& |
| _msg) { |
| fidl_init_txn_header( |
| &_msg.message()->_hdr, 0, |
| kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void TestProtocol::SetTransactionHeaderFor:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest( |
| const ::fidl::DecodedMessage< |
| TestProtocol:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest>& _msg) { |
| fidl_init_txn_header( |
| &_msg.message()->_hdr, 0, |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void TestProtocol::SetTransactionHeaderFor:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse( |
| const ::fidl::DecodedMessage< |
| TestProtocol:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>& _msg) { |
| fidl_init_txn_header( |
| &_msg.message()->_hdr, 0, |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| auto ::llcpp::fidl::test::json::NewerSimpleUnion::which() const -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kI: |
| case Ordinal::kS: |
| case Ordinal::kV: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::NewerSimpleUnion:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(NewerSimpleUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(NewerSimpleUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(NewerSimpleUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| auto ::llcpp::fidl::test::json::FlexibleUnion::which() const -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kPrimitive: |
| case Ordinal::kStringNeedsConstructor: |
| case Ordinal::kVectorStringAlsoNeedsConstructor: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::FlexibleUnion::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(FlexibleUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(FlexibleUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(FlexibleUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| auto ::llcpp::fidl::test::json::FlexibleFoo::which() const -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kS: |
| case Ordinal::kI: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::FlexibleFoo::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(FlexibleFoo) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(FlexibleFoo, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(FlexibleFoo, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::FieldCollision::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(FieldCollision) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(FieldCollision, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(FieldCollision, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| auto ::llcpp::fidl::test::json::ExplicitXUnion::which() const -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kI: |
| case Ordinal::kF: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::ExplicitXUnion::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ExplicitXUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ExplicitXUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ExplicitXUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::ExplicitUnion::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ExplicitUnion) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ExplicitUnion, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ExplicitUnion, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fidl::test::json::ExplicitStrictFoo:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ExplicitStrictFoo) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ExplicitStrictFoo, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ExplicitStrictFoo, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| auto ::llcpp::fidl::test::json::ExplicitFoo::which() const -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kS: |
| case Ordinal::kI: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::ExplicitFoo::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ExplicitFoo) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ExplicitFoo, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ExplicitFoo, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| auto ::llcpp::fidl::test::json::XUnionContainingEmptyStruct::which() const |
| -> Tag { |
| ZX_ASSERT(!has_invalid_tag()); |
| switch (ordinal_) { |
| case Ordinal::kEmpty: |
| return static_cast<Tag>(ordinal_); |
| default: |
| return Tag::kUnknown; |
| } |
| } |
| |
| void ::llcpp::fidl::test::json::XUnionContainingEmptyStruct:: |
| SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(XUnionContainingEmptyStruct) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(XUnionContainingEmptyStruct, ordinal_) == |
| offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(XUnionContainingEmptyStruct, envelope_) == |
| offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| } // namespace json |
| } // namespace test |
| } // namespace fidl |
| } // namespace llcpp |
