| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <fidl/test/union/llcpp/fidl.h> |
| |
| #include <memory> |
| |
| namespace llcpp { |
| |
| namespace fidl { |
| namespace test { |
| namespace union_ { |
| |
| void ::llcpp::fidl::test::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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 = |
| 8393311445612289086lu; |
| extern "C" const fidl_type_t |
| fidl_test_union_TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedRequestTable; |
| extern "C" const fidl_type_t |
| fidl_test_union_TestProtocolStrictXUnionHenceResponseMayBeStackAllocatedResponseTable; |
| [[maybe_unused]] constexpr uint64_t |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_Ordinal = |
| 6296412872266712530lu; |
| extern "C" const fidl_type_t |
| fidl_test_union_TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedRequestTable; |
| extern "C" const fidl_type_t |
| fidl_test_union_TestProtocolFlexibleXUnionHenceResponseMustBeHeapAllocatedResponseTable; |
| |
| } // namespace |
| TestProtocol::ResultOf::StrictXUnionHenceResponseMayBeStackAllocated:: |
| StrictXUnionHenceResponseMayBeStackAllocated(zx_handle_t _client) { |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest::OwnedEncodedMessage |
| _request(zx_txid_t(0)); |
| _request.GetOutgoingMessage() |
| .Call<StrictXUnionHenceResponseMayBeStackAllocatedResponse>( |
| _client, bytes_, |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse::PrimarySize + |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse:: |
| MaxOutOfLine); |
| status_ = _request.status(); |
| error_ = _request.error(); |
| } |
| |
| TestProtocol::ResultOf::StrictXUnionHenceResponseMayBeStackAllocated:: |
| StrictXUnionHenceResponseMayBeStackAllocated(zx_handle_t _client, |
| zx_time_t _deadline) { |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest::OwnedEncodedMessage |
| _request(zx_txid_t(0)); |
| _request.GetOutgoingMessage() |
| .Call<StrictXUnionHenceResponseMayBeStackAllocatedResponse>( |
| _client, bytes_, |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse::PrimarySize + |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse:: |
| MaxOutOfLine, |
| _deadline); |
| status_ = _request.status(); |
| error_ = _request.error(); |
| } |
| |
| TestProtocol::UnownedResultOf::StrictXUnionHenceResponseMayBeStackAllocated:: |
| StrictXUnionHenceResponseMayBeStackAllocated( |
| zx_handle_t _client, uint8_t* _response_bytes, |
| uint32_t _response_byte_capacity) |
| : bytes_(_response_bytes) { |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest::OwnedEncodedMessage |
| _request(zx_txid_t(0)); |
| _request.GetOutgoingMessage() |
| .Call<StrictXUnionHenceResponseMayBeStackAllocatedResponse>( |
| _client, _response_bytes, _response_byte_capacity); |
| status_ = _request.status(); |
| error_ = _request.error(); |
| } |
| |
| TestProtocol::ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated(zx_handle_t _client) |
| : bytes_(std::make_unique< |
| ::fidl::internal::AlignedBuffer<ZX_CHANNEL_MAX_MSG_BYTES>>()) { |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::OwnedEncodedMessage |
| _request(zx_txid_t(0)); |
| _request.GetOutgoingMessage() |
| .Call<FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>( |
| _client, bytes_->data(), ZX_CHANNEL_MAX_MSG_BYTES); |
| status_ = _request.status(); |
| error_ = _request.error(); |
| } |
| |
| TestProtocol::ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated(zx_handle_t _client, |
| zx_time_t _deadline) |
| : bytes_(std::make_unique< |
| ::fidl::internal::AlignedBuffer<ZX_CHANNEL_MAX_MSG_BYTES>>()) { |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::OwnedEncodedMessage |
| _request(zx_txid_t(0)); |
| _request.GetOutgoingMessage() |
| .Call<FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>( |
| _client, bytes_->data(), ZX_CHANNEL_MAX_MSG_BYTES, _deadline); |
| status_ = _request.status(); |
| error_ = _request.error(); |
| } |
| |
| TestProtocol::UnownedResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| zx_handle_t _client, uint8_t* _response_bytes, |
| uint32_t _response_byte_capacity) |
| : bytes_(_response_bytes) { |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::OwnedEncodedMessage |
| _request(zx_txid_t(0)); |
| _request.GetOutgoingMessage() |
| .Call<FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse>( |
| _client, _response_bytes, _response_byte_capacity); |
| status_ = _request.status(); |
| error_ = _request.error(); |
| } |
| |
| TestProtocol::ResultOf::StrictXUnionHenceResponseMayBeStackAllocated |
| TestProtocol::ClientImpl::StrictXUnionHenceResponseMayBeStackAllocated_Sync() { |
| if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) { |
| return ResultOf::StrictXUnionHenceResponseMayBeStackAllocated( |
| _channel->handle()); |
| } |
| return TestProtocol::ResultOf::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound)); |
| } |
| |
| TestProtocol::UnownedResultOf::StrictXUnionHenceResponseMayBeStackAllocated |
| TestProtocol::ClientImpl::StrictXUnionHenceResponseMayBeStackAllocated_Sync( |
| ::fidl::BufferSpan _response_buffer) { |
| if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) { |
| return UnownedResultOf::StrictXUnionHenceResponseMayBeStackAllocated( |
| _channel->handle(), _response_buffer.data, _response_buffer.capacity); |
| } |
| return TestProtocol::UnownedResultOf:: |
| StrictXUnionHenceResponseMayBeStackAllocated( |
| ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound)); |
| } |
| |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponseContext:: |
| StrictXUnionHenceResponseMayBeStackAllocatedResponseContext() |
| : ::fidl::internal::ResponseContext( |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse::Type, |
| kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_Ordinal) {} |
| |
| void TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponseContext:: |
| OnReply(uint8_t* reply) { |
| OnReply( |
| reinterpret_cast<StrictXUnionHenceResponseMayBeStackAllocatedResponse*>( |
| reply)); |
| } |
| |
| ::fidl::Result |
| TestProtocol::ClientImpl::StrictXUnionHenceResponseMayBeStackAllocated( |
| ::fit::callback< |
| void(StrictXUnionHenceResponseMayBeStackAllocatedResponse* response)> |
| _cb) { |
| class ResponseContext final |
| : public StrictXUnionHenceResponseMayBeStackAllocatedResponseContext { |
| public: |
| ResponseContext( |
| ::fit::callback<void( |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse* response)> |
| cb) |
| : cb_(std::move(cb)) {} |
| |
| void OnReply(StrictXUnionHenceResponseMayBeStackAllocatedResponse* response) |
| override { |
| cb_(response); |
| |
| delete this; |
| } |
| |
| void OnError() override { delete this; } |
| |
| private: |
| ::fit::callback<void( |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse* response)> |
| cb_; |
| }; |
| |
| auto* _context = new ResponseContext(std::move(_cb)); |
| ::fidl::internal::ClientBase::PrepareAsyncTxn(_context); |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest::OwnedEncodedMessage |
| _request(_context->Txid()); |
| return _request.GetOutgoingMessage().Write(this, _context); |
| } |
| |
| ::fidl::Result |
| TestProtocol::ClientImpl::StrictXUnionHenceResponseMayBeStackAllocated( |
| StrictXUnionHenceResponseMayBeStackAllocatedResponseContext* _context) { |
| ::fidl::internal::ClientBase::PrepareAsyncTxn(_context); |
| |
| StrictXUnionHenceResponseMayBeStackAllocatedRequest::OwnedEncodedMessage |
| _request(_context->Txid()); |
| return _request.GetOutgoingMessage().Write(this, _context); |
| } |
| |
| TestProtocol::ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated |
| TestProtocol::ClientImpl:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated_Sync() { |
| if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) { |
| return ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| _channel->handle()); |
| } |
| return TestProtocol::ResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound)); |
| } |
| |
| TestProtocol::UnownedResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated |
| TestProtocol::ClientImpl::FlexibleXUnionHenceResponseMustBeHeapAllocated_Sync( |
| ::fidl::BufferSpan _response_buffer) { |
| if (auto _channel = ::fidl::internal::ClientBase::GetChannel()) { |
| return UnownedResultOf::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| _channel->handle(), _response_buffer.data, _response_buffer.capacity); |
| } |
| return TestProtocol::UnownedResultOf:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::fidl::Result(ZX_ERR_CANCELED, ::fidl::kErrorChannelUnbound)); |
| } |
| |
| TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseContext:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseContext() |
| : ::fidl::internal::ResponseContext( |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse::Type, |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_Ordinal) { |
| } |
| |
| void TestProtocol:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseContext::OnReply( |
| uint8_t* reply) { |
| OnReply( |
| reinterpret_cast<FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse*>( |
| reply)); |
| } |
| |
| ::fidl::Result |
| TestProtocol::ClientImpl::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| ::fit::callback< |
| void(FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse* response)> |
| _cb) { |
| class ResponseContext final |
| : public FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseContext { |
| public: |
| ResponseContext( |
| ::fit::callback<void( |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse* response)> |
| cb) |
| : cb_(std::move(cb)) {} |
| |
| void OnReply(FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse* |
| response) override { |
| cb_(response); |
| |
| delete this; |
| } |
| |
| void OnError() override { delete this; } |
| |
| private: |
| ::fit::callback<void( |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse* response)> |
| cb_; |
| }; |
| |
| auto* _context = new ResponseContext(std::move(_cb)); |
| ::fidl::internal::ClientBase::PrepareAsyncTxn(_context); |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::OwnedEncodedMessage |
| _request(_context->Txid()); |
| return _request.GetOutgoingMessage().Write(this, _context); |
| } |
| |
| ::fidl::Result |
| TestProtocol::ClientImpl::FlexibleXUnionHenceResponseMustBeHeapAllocated( |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponseContext* _context) { |
| ::fidl::internal::ClientBase::PrepareAsyncTxn(_context); |
| |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::OwnedEncodedMessage |
| _request(_context->Txid()); |
| return _request.GetOutgoingMessage().Write(this, _context); |
| } |
| |
| std::optional<::fidl::UnbindInfo> TestProtocol::ClientImpl::DispatchEvent( |
| fidl_incoming_msg_t* msg) { |
| fidl_message_header_t* hdr = |
| reinterpret_cast<fidl_message_header_t*>(msg->bytes); |
| switch (hdr->ordinal) { |
| default: |
| FidlHandleInfoCloseMany(msg->handles, msg->num_handles); |
| return ::fidl::UnbindInfo{::fidl::UnbindInfo::kUnexpectedMessage, |
| ZX_ERR_NOT_SUPPORTED}; |
| } |
| return {}; |
| } |
| |
| namespace methods { |
| |
| void TestProtocolDispatchStrictXUnionHenceResponseMayBeStackAllocated( |
| void* interface, void* bytes, ::fidl::Transaction* txn) { |
| TestProtocol::Interface:: |
| StrictXUnionHenceResponseMayBeStackAllocatedCompleter::Sync completer( |
| txn); |
| reinterpret_cast<TestProtocol::Interface*>(interface) |
| ->StrictXUnionHenceResponseMayBeStackAllocated(completer); |
| } |
| |
| void TestProtocolDispatchFlexibleXUnionHenceResponseMustBeHeapAllocated( |
| void* interface, void* bytes, ::fidl::Transaction* txn) { |
| TestProtocol::Interface:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedCompleter::Sync completer( |
| txn); |
| reinterpret_cast<TestProtocol::Interface*>(interface) |
| ->FlexibleXUnionHenceResponseMustBeHeapAllocated(completer); |
| } |
| |
| } // namespace methods |
| |
| namespace entries { |
| |
| ::fidl::internal::MethodEntry TestProtocol[] = { |
| {kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_Ordinal, |
| TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedRequest::Type, |
| methods::TestProtocolDispatchStrictXUnionHenceResponseMayBeStackAllocated}, |
| {kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_Ordinal, |
| TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest::Type, |
| methods:: |
| TestProtocolDispatchFlexibleXUnionHenceResponseMustBeHeapAllocated}, |
| }; |
| |
| } // namespace entries |
| |
| ::fidl::DispatchResult TestProtocol::TryDispatch(Interface* impl, |
| fidl_incoming_msg_t* msg, |
| ::fidl::Transaction* txn) { |
| return ::fidl::internal::TryDispatch( |
| impl, msg, txn, entries::TestProtocol, |
| entries::TestProtocol + sizeof(entries::TestProtocol) / |
| sizeof(::fidl::internal::MethodEntry)); |
| } |
| |
| ::fidl::DispatchResult TestProtocol::Dispatch(Interface* impl, |
| fidl_incoming_msg_t* msg, |
| ::fidl::Transaction* txn) { |
| ::fidl::DispatchResult dispatch_result = TryDispatch(impl, msg, txn); |
| if (dispatch_result == ::fidl::DispatchResult::kNotFound) { |
| FidlHandleInfoCloseMany(msg->handles, msg->num_handles); |
| txn->InternalError( |
| {::fidl::UnbindInfo::kUnexpectedMessage, ZX_ERR_NOT_SUPPORTED}); |
| } |
| return dispatch_result; |
| } |
| |
| ::fidl::DispatchResult TestProtocol::Interface::dispatch_message( |
| fidl_incoming_msg_t* msg, ::fidl::Transaction* txn) { |
| return TestProtocol::Dispatch(this, msg, txn); |
| } |
| |
| ::fidl::Result TestProtocol::Interface:: |
| StrictXUnionHenceResponseMayBeStackAllocatedCompleterBase::Reply( |
| ::llcpp::fidl::test::union_::StrictBoundedXUnion xu) { |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse::OwnedEncodedMessage |
| _response{xu}; |
| return CompleterBase::SendReply(&_response.GetOutgoingMessage()); |
| } |
| |
| ::fidl::Result TestProtocol::Interface:: |
| StrictXUnionHenceResponseMayBeStackAllocatedCompleterBase::Reply( |
| ::fidl::BufferSpan _buffer, |
| ::llcpp::fidl::test::union_::StrictBoundedXUnion xu) { |
| StrictXUnionHenceResponseMayBeStackAllocatedResponse::UnownedEncodedMessage |
| _response(_buffer.data, _buffer.capacity, xu); |
| return CompleterBase::SendReply(&_response.GetOutgoingMessage()); |
| } |
| |
| ::fidl::Result TestProtocol::Interface:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedCompleterBase::Reply( |
| ::llcpp::fidl::test::union_::OlderSimpleUnion xu) { |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse::OwnedEncodedMessage |
| _response{xu}; |
| return CompleterBase::SendReply(&_response.GetOutgoingMessage()); |
| } |
| |
| ::fidl::Result TestProtocol::Interface:: |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedCompleterBase::Reply( |
| ::fidl::BufferSpan _buffer, |
| ::llcpp::fidl::test::union_::OlderSimpleUnion xu) { |
| FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse::UnownedEncodedMessage |
| _response(_buffer.data, _buffer.capacity, xu); |
| return CompleterBase::SendReply(&_response.GetOutgoingMessage()); |
| } |
| |
| void TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedRequest:: |
| _InitHeader(zx_txid_t _txid) { |
| fidl_init_txn_header( |
| &_hdr, _txid, |
| kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_Ordinal); |
| } |
| |
| void TestProtocol::StrictXUnionHenceResponseMayBeStackAllocatedResponse:: |
| _InitHeader() { |
| fidl_init_txn_header( |
| &_hdr, 0, |
| kTestProtocol_StrictXUnionHenceResponseMayBeStackAllocated_Ordinal); |
| } |
| |
| void TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedRequest:: |
| _InitHeader(zx_txid_t _txid) { |
| fidl_init_txn_header( |
| &_hdr, _txid, |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_Ordinal); |
| } |
| |
| void TestProtocol::FlexibleXUnionHenceResponseMustBeHeapAllocatedResponse:: |
| _InitHeader() { |
| fidl_init_txn_header( |
| &_hdr, 0, |
| kTestProtocol_FlexibleXUnionHenceResponseMustBeHeapAllocated_Ordinal); |
| } |
| |
| auto ::llcpp::fidl::test::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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::union_::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 union_ |
| } // namespace test |
| } // namespace fidl |
| } // namespace llcpp |
