| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <fuchsia/boot/llcpp/fidl.h> |
| #include <memory> |
| |
| namespace llcpp { |
| |
| namespace fuchsia { |
| namespace boot { |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kWriteOnlyLog_Get_Ordinal = 0x6bf285c200000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kWriteOnlyLog_Get_GenOrdinal = 0x4579dac289d3007lu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetResponseTable; |
| |
| } // namespace |
| template <> |
| WriteOnlyLog::ResultOf::Get_Impl<WriteOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| WriteOnlyLog::InPlace::Get(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| WriteOnlyLog::ResultOf::Get WriteOnlyLog::SyncClient::Get() { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_)); |
| } |
| |
| WriteOnlyLog::ResultOf::Get WriteOnlyLog::Call::Get(::zx::unowned_channel _client_end) { |
| return ResultOf::Get(std::move(_client_end)); |
| } |
| |
| template <> |
| WriteOnlyLog::UnownedResultOf::Get_Impl<WriteOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| WriteOnlyLog::InPlace::Get(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| WriteOnlyLog::UnownedResultOf::Get WriteOnlyLog::SyncClient::Get(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| WriteOnlyLog::UnownedResultOf::Get WriteOnlyLog::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<WriteOnlyLog::GetResponse> WriteOnlyLog::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer)); |
| WriteOnlyLog::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<WriteOnlyLog::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<WriteOnlyLog::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool WriteOnlyLog::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 kWriteOnlyLog_Get_Ordinal: |
| case kWriteOnlyLog_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->Get( |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool WriteOnlyLog::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 WriteOnlyLog::Interface::GetCompleterBase::Reply(::zx::debuglog log) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| WriteOnlyLog::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.log = std::move(log); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void WriteOnlyLog::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::debuglog log) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| WriteOnlyLog::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.log = std::move(log); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void WriteOnlyLog::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| WriteOnlyLog::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void WriteOnlyLog::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<WriteOnlyLog::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kWriteOnlyLog_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void WriteOnlyLog::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<WriteOnlyLog::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kWriteOnlyLog_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kReadOnlyLog_Get_Ordinal = 0x6ef326c600000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kReadOnlyLog_Get_GenOrdinal = 0x6f3ceba5eca871fflu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetResponseTable; |
| |
| } // namespace |
| template <> |
| ReadOnlyLog::ResultOf::Get_Impl<ReadOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| ReadOnlyLog::InPlace::Get(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| ReadOnlyLog::ResultOf::Get ReadOnlyLog::SyncClient::Get() { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_)); |
| } |
| |
| ReadOnlyLog::ResultOf::Get ReadOnlyLog::Call::Get(::zx::unowned_channel _client_end) { |
| return ResultOf::Get(std::move(_client_end)); |
| } |
| |
| template <> |
| ReadOnlyLog::UnownedResultOf::Get_Impl<ReadOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| ReadOnlyLog::InPlace::Get(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| ReadOnlyLog::UnownedResultOf::Get ReadOnlyLog::SyncClient::Get(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| ReadOnlyLog::UnownedResultOf::Get ReadOnlyLog::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ReadOnlyLog::GetResponse> ReadOnlyLog::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer)); |
| ReadOnlyLog::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ReadOnlyLog::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ReadOnlyLog::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool ReadOnlyLog::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 kReadOnlyLog_Get_Ordinal: |
| case kReadOnlyLog_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->Get( |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool ReadOnlyLog::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 ReadOnlyLog::Interface::GetCompleterBase::Reply(::zx::debuglog log) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| ReadOnlyLog::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.log = std::move(log); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void ReadOnlyLog::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::debuglog log) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| ReadOnlyLog::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.log = std::move(log); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void ReadOnlyLog::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| ReadOnlyLog::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void ReadOnlyLog::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<ReadOnlyLog::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kReadOnlyLog_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ReadOnlyLog::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<ReadOnlyLog::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kReadOnlyLog_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kItems_Get_Ordinal = 0x6462c85400000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kItems_Get_GenOrdinal = 0x542db3f176641edclu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetResponseTable; |
| |
| } // namespace |
| template <> |
| Items::ResultOf::Get_Impl<Items::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<GetRequest*>(_write_bytes); |
| _request.type = std::move(type); |
| _request.extra = std::move(extra); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Items::InPlace::Get(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| Items::ResultOf::Get Items::SyncClient::Get(uint32_t type, uint32_t extra) { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_), std::move(type), std::move(extra)); |
| } |
| |
| Items::ResultOf::Get Items::Call::Get(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra) { |
| return ResultOf::Get(std::move(_client_end), std::move(type), std::move(extra)); |
| } |
| |
| template <> |
| Items::UnownedResultOf::Get_Impl<Items::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < GetRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<GetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<GetRequest*>(_request_buffer.data()); |
| _request.type = std::move(type); |
| _request.extra = std::move(extra); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Items::InPlace::Get(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| Items::UnownedResultOf::Get Items::SyncClient::Get(::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(extra), std::move(_response_buffer)); |
| } |
| |
| Items::UnownedResultOf::Get Items::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(extra), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Items::GetResponse> Items::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRequest> params, ::fidl::BytePart response_buffer) { |
| Items::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Items::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Items::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool Items::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 kItems_Get_Ordinal: |
| case kItems_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->Get(std::move(message->type), std::move(message->extra), |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Items::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 Items::Interface::GetCompleterBase::Reply(::zx::vmo payload, uint32_t length) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| Items::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.payload = std::move(payload); |
| _response.length = std::move(length); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void Items::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| Items::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.payload = std::move(payload); |
| _response.length = std::move(length); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void Items::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| Items::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void Items::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<Items::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kItems_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void Items::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<Items::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kItems_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kFactoryItems_Get_Ordinal = 0x18be2c3500000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kFactoryItems_Get_GenOrdinal = 0x2f0dcb1aba41b6d9lu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetResponseTable; |
| |
| } // namespace |
| template <> |
| FactoryItems::ResultOf::Get_Impl<FactoryItems::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, uint32_t extra) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<GetRequest*>(_write_bytes); |
| _request.extra = std::move(extra); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| FactoryItems::InPlace::Get(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| FactoryItems::ResultOf::Get FactoryItems::SyncClient::Get(uint32_t extra) { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_), std::move(extra)); |
| } |
| |
| FactoryItems::ResultOf::Get FactoryItems::Call::Get(::zx::unowned_channel _client_end, uint32_t extra) { |
| return ResultOf::Get(std::move(_client_end), std::move(extra)); |
| } |
| |
| template <> |
| FactoryItems::UnownedResultOf::Get_Impl<FactoryItems::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < GetRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<GetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<GetRequest*>(_request_buffer.data()); |
| _request.extra = std::move(extra); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| FactoryItems::InPlace::Get(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| FactoryItems::UnownedResultOf::Get FactoryItems::SyncClient::Get(::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(extra), std::move(_response_buffer)); |
| } |
| |
| FactoryItems::UnownedResultOf::Get FactoryItems::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_request_buffer), std::move(extra), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<FactoryItems::GetResponse> FactoryItems::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRequest> params, ::fidl::BytePart response_buffer) { |
| FactoryItems::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<FactoryItems::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<FactoryItems::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool FactoryItems::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 kFactoryItems_Get_Ordinal: |
| case kFactoryItems_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->Get(std::move(message->extra), |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool FactoryItems::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 FactoryItems::Interface::GetCompleterBase::Reply(::zx::vmo payload, uint32_t length) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| FactoryItems::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.payload = std::move(payload); |
| _response.length = std::move(length); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void FactoryItems::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| FactoryItems::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.payload = std::move(payload); |
| _response.length = std::move(length); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void FactoryItems::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| FactoryItems::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void FactoryItems::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<FactoryItems::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kFactoryItems_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void FactoryItems::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<FactoryItems::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kFactoryItems_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kRootResource_Get_Ordinal = 0x2e9e3a1400000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kRootResource_Get_GenOrdinal = 0x5a1df646e4df6f78lu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetResponseTable; |
| |
| } // namespace |
| template <> |
| RootResource::ResultOf::Get_Impl<RootResource::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| RootResource::InPlace::Get(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| RootResource::ResultOf::Get RootResource::SyncClient::Get() { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_)); |
| } |
| |
| RootResource::ResultOf::Get RootResource::Call::Get(::zx::unowned_channel _client_end) { |
| return ResultOf::Get(std::move(_client_end)); |
| } |
| |
| template <> |
| RootResource::UnownedResultOf::Get_Impl<RootResource::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| RootResource::InPlace::Get(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| RootResource::UnownedResultOf::Get RootResource::SyncClient::Get(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| RootResource::UnownedResultOf::Get RootResource::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<RootResource::GetResponse> RootResource::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer)); |
| RootResource::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<RootResource::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<RootResource::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool RootResource::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 kRootResource_Get_Ordinal: |
| case kRootResource_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->Get( |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool RootResource::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 RootResource::Interface::GetCompleterBase::Reply(::zx::resource resource) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| RootResource::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.resource = std::move(resource); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void RootResource::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::resource resource) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| RootResource::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.resource = std::move(resource); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void RootResource::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| RootResource::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void RootResource::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootResource::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootResource_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void RootResource::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootResource::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootResource_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kRootJob_Get_Ordinal = 0x7e473a2400000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kRootJob_Get_GenOrdinal = 0x70e2566b29e1af06lu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetResponseTable; |
| |
| } // namespace |
| template <> |
| RootJob::ResultOf::Get_Impl<RootJob::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| RootJob::InPlace::Get(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| RootJob::ResultOf::Get RootJob::SyncClient::Get() { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_)); |
| } |
| |
| RootJob::ResultOf::Get RootJob::Call::Get(::zx::unowned_channel _client_end) { |
| return ResultOf::Get(std::move(_client_end)); |
| } |
| |
| template <> |
| RootJob::UnownedResultOf::Get_Impl<RootJob::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| RootJob::InPlace::Get(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| RootJob::UnownedResultOf::Get RootJob::SyncClient::Get(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| RootJob::UnownedResultOf::Get RootJob::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<RootJob::GetResponse> RootJob::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer)); |
| RootJob::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<RootJob::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<RootJob::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool RootJob::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 kRootJob_Get_Ordinal: |
| case kRootJob_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->Get( |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool RootJob::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 RootJob::Interface::GetCompleterBase::Reply(::zx::job job) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| RootJob::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.job = std::move(job); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void RootJob::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::job job) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| RootJob::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.job = std::move(job); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void RootJob::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| RootJob::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void RootJob::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootJob::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJob_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void RootJob::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootJob::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJob_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kRootJobForInspect_Get_Ordinal = 0x7e473a2400000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kRootJobForInspect_Get_GenOrdinal = 0x70e2566b29e1af06lu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetResponseTable; |
| |
| } // namespace |
| template <> |
| RootJobForInspect::ResultOf::Get_Impl<RootJobForInspect::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| RootJobForInspect::InPlace::Get(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| RootJobForInspect::ResultOf::Get RootJobForInspect::SyncClient::Get() { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_)); |
| } |
| |
| RootJobForInspect::ResultOf::Get RootJobForInspect::Call::Get(::zx::unowned_channel _client_end) { |
| return ResultOf::Get(std::move(_client_end)); |
| } |
| |
| template <> |
| RootJobForInspect::UnownedResultOf::Get_Impl<RootJobForInspect::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| RootJobForInspect::InPlace::Get(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| RootJobForInspect::UnownedResultOf::Get RootJobForInspect::SyncClient::Get(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| RootJobForInspect::UnownedResultOf::Get RootJobForInspect::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<RootJobForInspect::GetResponse> RootJobForInspect::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer)); |
| RootJobForInspect::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<RootJobForInspect::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<RootJobForInspect::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool RootJobForInspect::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 kRootJobForInspect_Get_Ordinal: |
| case kRootJobForInspect_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->Get( |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool RootJobForInspect::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 RootJobForInspect::Interface::GetCompleterBase::Reply(::zx::job job) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| RootJobForInspect::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.job = std::move(job); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void RootJobForInspect::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::job job) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| RootJobForInspect::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.job = std::move(job); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void RootJobForInspect::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| RootJobForInspect::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void RootJobForInspect::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootJobForInspect::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJobForInspect_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void RootJobForInspect::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootJobForInspect::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJobForInspect_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kArguments_Get_Ordinal = 0x6e7258e600000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kArguments_Get_GenOrdinal = 0x2e594d9c82b93ee3lu; |
| extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetResponseTable; |
| |
| } // namespace |
| template <> |
| Arguments::ResultOf::Get_Impl<Arguments::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Arguments::InPlace::Get(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| Arguments::ResultOf::Get Arguments::SyncClient::Get() { |
| return ResultOf::Get(::zx::unowned_channel(this->channel_)); |
| } |
| |
| Arguments::ResultOf::Get Arguments::Call::Get(::zx::unowned_channel _client_end) { |
| return ResultOf::Get(std::move(_client_end)); |
| } |
| |
| template <> |
| Arguments::UnownedResultOf::Get_Impl<Arguments::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetRequest)); |
| ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Arguments::InPlace::Get(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| Arguments::UnownedResultOf::Get Arguments::SyncClient::Get(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| Arguments::UnownedResultOf::Get Arguments::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Arguments::GetResponse> Arguments::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer)); |
| Arguments::SetTransactionHeaderFor::GetRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Arguments::GetResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetRequest, GetResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Arguments::GetResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool Arguments::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 kArguments_Get_Ordinal: |
| case kArguments_Get_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->Get( |
| Interface::GetCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Arguments::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 Arguments::Interface::GetCompleterBase::Reply(::zx::vmo vmo, uint64_t size) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes); |
| Arguments::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.vmo = std::move(vmo); |
| _response.size = std::move(size); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes))); |
| } |
| |
| void Arguments::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size) { |
| if (_buffer.capacity() < GetResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data()); |
| Arguments::SetTransactionHeaderFor::GetResponse( |
| ::fidl::DecodedMessage<GetResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetResponse::PrimarySize, |
| GetResponse::PrimarySize))); |
| _response.vmo = std::move(vmo); |
| _response.size = std::move(size); |
| _buffer.set_actual(sizeof(GetResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer))); |
| } |
| |
| void Arguments::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) { |
| Arguments::SetTransactionHeaderFor::GetResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void Arguments::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<Arguments::GetRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kArguments_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void Arguments::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<Arguments::GetResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kArguments_Get_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| } // namespace boot |
| } // namespace fuchsia |
| } // namespace llcpp |