| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <fuchsia/process/llcpp/fidl.h> |
| #include <memory> |
| |
| namespace llcpp { |
| |
| namespace fuchsia { |
| namespace process { |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kResolver_Resolve_Ordinal = 0x20980a8100000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kResolver_Resolve_GenOrdinal = 0x3c15951efde89c90lu; |
| extern "C" const fidl_type_t v1_fuchsia_process_ResolverResolveRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_process_ResolverResolveResponseTable; |
| |
| } // namespace |
| template <> |
| Resolver::ResultOf::Resolve_Impl<Resolver::ResolveResponse>::Resolve_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResolveRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| ResolveRequest _request = {}; |
| _request.name = std::move(name); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<ResolveRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| Resolver::InPlace::Resolve(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| Resolver::ResultOf::Resolve Resolver::SyncClient::Resolve(::fidl::StringView name) { |
| return ResultOf::Resolve(::zx::unowned_channel(this->channel_), std::move(name)); |
| } |
| |
| Resolver::ResultOf::Resolve Resolver::Call::Resolve(::zx::unowned_channel _client_end, ::fidl::StringView name) { |
| return ResultOf::Resolve(std::move(_client_end), std::move(name)); |
| } |
| |
| template <> |
| Resolver::UnownedResultOf::Resolve_Impl<Resolver::ResolveResponse>::Resolve_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < ResolveRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<ResolveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| ResolveRequest _request = {}; |
| _request.name = std::move(name); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<ResolveRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| Resolver::InPlace::Resolve(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| Resolver::UnownedResultOf::Resolve Resolver::SyncClient::Resolve(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Resolve(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(name), std::move(_response_buffer)); |
| } |
| |
| Resolver::UnownedResultOf::Resolve Resolver::Call::Resolve(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Resolve(std::move(_client_end), std::move(_request_buffer), std::move(name), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Resolver::ResolveResponse> Resolver::InPlace::Resolve(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResolveRequest> params, ::fidl::BytePart response_buffer) { |
| Resolver::SetTransactionHeaderFor::ResolveRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Resolver::ResolveResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<ResolveRequest, ResolveResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Resolver::ResolveResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool Resolver::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 kResolver_Resolve_Ordinal: |
| case kResolver_Resolve_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<ResolveRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->Resolve(std::move(message->name), |
| Interface::ResolveCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Resolver::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 Resolver::Interface::ResolveCompleterBase::Reply(int32_t status, ::zx::vmo executable, ::zx::channel ldsvc) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResolveResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<ResolveResponse*>(_write_bytes); |
| Resolver::SetTransactionHeaderFor::ResolveResponse( |
| ::fidl::DecodedMessage<ResolveResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| ResolveResponse::PrimarySize, |
| ResolveResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.executable = std::move(executable); |
| _response.ldsvc = std::move(ldsvc); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResolveResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<ResolveResponse>(std::move(_response_bytes))); |
| } |
| |
| void Resolver::Interface::ResolveCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::vmo executable, ::zx::channel ldsvc) { |
| if (_buffer.capacity() < ResolveResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<ResolveResponse*>(_buffer.data()); |
| Resolver::SetTransactionHeaderFor::ResolveResponse( |
| ::fidl::DecodedMessage<ResolveResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| ResolveResponse::PrimarySize, |
| ResolveResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.executable = std::move(executable); |
| _response.ldsvc = std::move(ldsvc); |
| _buffer.set_actual(sizeof(ResolveResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<ResolveResponse>(std::move(_buffer))); |
| } |
| |
| void Resolver::Interface::ResolveCompleterBase::Reply(::fidl::DecodedMessage<ResolveResponse> params) { |
| Resolver::SetTransactionHeaderFor::ResolveResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void Resolver::SetTransactionHeaderFor::ResolveRequest(const ::fidl::DecodedMessage<Resolver::ResolveRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kResolver_Resolve_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void Resolver::SetTransactionHeaderFor::ResolveResponse(const ::fidl::DecodedMessage<Resolver::ResolveResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kResolver_Resolve_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_Launch_Ordinal = 0x26884d9d00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_Launch_GenOrdinal = 0x11335a9928afbfa4lu; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherLaunchRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherLaunchResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_CreateWithoutStarting_Ordinal = 0x4fcfbc1100000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_CreateWithoutStarting_GenOrdinal = 0x755f8263fe51cb61lu; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherCreateWithoutStartingRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherCreateWithoutStartingResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddArgs_Ordinal = 0x1480f9a000000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddArgs_GenOrdinal = 0x3be445d3e4fd6512lu; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddArgsRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddArgsResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddEnvirons_Ordinal = 0x48c62c9900000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddEnvirons_GenOrdinal = 0x73a3c97fa7fe1779lu; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddEnvironsRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddEnvironsResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddNames_Ordinal = 0x53fcef0c00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddNames_GenOrdinal = 0x2579ee2c7be28662lu; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddNamesRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddNamesResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddHandles_Ordinal = 0x5cd6900b00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kLauncher_AddHandles_GenOrdinal = 0x51025267a537a615lu; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddHandlesRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddHandlesResponseTable; |
| |
| } // namespace |
| template <> |
| Launcher::ResultOf::Launch_Impl<Launcher::LaunchResponse>::Launch_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LaunchRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| LaunchRequest _request = {}; |
| _request.info = std::move(info); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<LaunchRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| Launcher::InPlace::Launch(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| Launcher::ResultOf::Launch Launcher::SyncClient::Launch(::llcpp::fuchsia::process::LaunchInfo info) { |
| return ResultOf::Launch(::zx::unowned_channel(this->channel_), std::move(info)); |
| } |
| |
| Launcher::ResultOf::Launch Launcher::Call::Launch(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) { |
| return ResultOf::Launch(std::move(_client_end), std::move(info)); |
| } |
| |
| template <> |
| Launcher::UnownedResultOf::Launch_Impl<Launcher::LaunchResponse>::Launch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < LaunchRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<LaunchResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| LaunchRequest _request = {}; |
| _request.info = std::move(info); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<LaunchRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| Launcher::InPlace::Launch(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| Launcher::UnownedResultOf::Launch Launcher::SyncClient::Launch(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Launch(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(info), std::move(_response_buffer)); |
| } |
| |
| Launcher::UnownedResultOf::Launch Launcher::Call::Launch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Launch(std::move(_client_end), std::move(_request_buffer), std::move(info), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Launcher::LaunchResponse> Launcher::InPlace::Launch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LaunchRequest> params, ::fidl::BytePart response_buffer) { |
| Launcher::SetTransactionHeaderFor::LaunchRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Launcher::LaunchResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<LaunchRequest, LaunchResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Launcher::LaunchResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| Launcher::ResultOf::CreateWithoutStarting_Impl<Launcher::CreateWithoutStartingResponse>::CreateWithoutStarting_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateWithoutStartingRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| CreateWithoutStartingRequest _request = {}; |
| _request.info = std::move(info); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<CreateWithoutStartingRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| Launcher::InPlace::CreateWithoutStarting(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| Launcher::ResultOf::CreateWithoutStarting Launcher::SyncClient::CreateWithoutStarting(::llcpp::fuchsia::process::LaunchInfo info) { |
| return ResultOf::CreateWithoutStarting(::zx::unowned_channel(this->channel_), std::move(info)); |
| } |
| |
| Launcher::ResultOf::CreateWithoutStarting Launcher::Call::CreateWithoutStarting(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) { |
| return ResultOf::CreateWithoutStarting(std::move(_client_end), std::move(info)); |
| } |
| |
| template <> |
| Launcher::UnownedResultOf::CreateWithoutStarting_Impl<Launcher::CreateWithoutStartingResponse>::CreateWithoutStarting_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < CreateWithoutStartingRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<CreateWithoutStartingResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| CreateWithoutStartingRequest _request = {}; |
| _request.info = std::move(info); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<CreateWithoutStartingRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| Launcher::InPlace::CreateWithoutStarting(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| Launcher::UnownedResultOf::CreateWithoutStarting Launcher::SyncClient::CreateWithoutStarting(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::CreateWithoutStarting(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(info), std::move(_response_buffer)); |
| } |
| |
| Launcher::UnownedResultOf::CreateWithoutStarting Launcher::Call::CreateWithoutStarting(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::CreateWithoutStarting(std::move(_client_end), std::move(_request_buffer), std::move(info), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Launcher::CreateWithoutStartingResponse> Launcher::InPlace::CreateWithoutStarting(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateWithoutStartingRequest> params, ::fidl::BytePart response_buffer) { |
| Launcher::SetTransactionHeaderFor::CreateWithoutStartingRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Launcher::CreateWithoutStartingResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<CreateWithoutStartingRequest, CreateWithoutStartingResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Launcher::CreateWithoutStartingResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| Launcher::ResultOf::AddArgs_Impl::AddArgs_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddArgsRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| AddArgsRequest _request = {}; |
| _request.args = std::move(args); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddArgsRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddArgs(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::ResultOf::AddArgs Launcher::SyncClient::AddArgs(::fidl::VectorView<::fidl::VectorView<uint8_t>> args) { |
| return ResultOf::AddArgs(::zx::unowned_channel(this->channel_), std::move(args)); |
| } |
| |
| Launcher::ResultOf::AddArgs Launcher::Call::AddArgs(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) { |
| return ResultOf::AddArgs(std::move(_client_end), std::move(args)); |
| } |
| |
| |
| Launcher::UnownedResultOf::AddArgs_Impl::AddArgs_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) { |
| if (_request_buffer.capacity() < AddArgsRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| AddArgsRequest _request = {}; |
| _request.args = std::move(args); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddArgsRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddArgs(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::UnownedResultOf::AddArgs Launcher::SyncClient::AddArgs(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) { |
| return UnownedResultOf::AddArgs(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(args)); |
| } |
| |
| Launcher::UnownedResultOf::AddArgs Launcher::Call::AddArgs(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) { |
| return UnownedResultOf::AddArgs(std::move(_client_end), std::move(_request_buffer), std::move(args)); |
| } |
| |
| ::fidl::internal::StatusAndError Launcher::InPlace::AddArgs(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddArgsRequest> params) { |
| Launcher::SetTransactionHeaderFor::AddArgsRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::internal::StatusAndError::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| zx_status_t _write_status = |
| ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message)); |
| if (_write_status != ZX_OK) { |
| return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed); |
| } else { |
| return ::fidl::internal::StatusAndError(ZX_OK, nullptr); |
| } |
| } |
| |
| |
| Launcher::ResultOf::AddEnvirons_Impl::AddEnvirons_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddEnvironsRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| AddEnvironsRequest _request = {}; |
| _request.environ = std::move(environ); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddEnvironsRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddEnvirons(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::ResultOf::AddEnvirons Launcher::SyncClient::AddEnvirons(::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) { |
| return ResultOf::AddEnvirons(::zx::unowned_channel(this->channel_), std::move(environ)); |
| } |
| |
| Launcher::ResultOf::AddEnvirons Launcher::Call::AddEnvirons(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) { |
| return ResultOf::AddEnvirons(std::move(_client_end), std::move(environ)); |
| } |
| |
| |
| Launcher::UnownedResultOf::AddEnvirons_Impl::AddEnvirons_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) { |
| if (_request_buffer.capacity() < AddEnvironsRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| AddEnvironsRequest _request = {}; |
| _request.environ = std::move(environ); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddEnvironsRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddEnvirons(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::UnownedResultOf::AddEnvirons Launcher::SyncClient::AddEnvirons(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) { |
| return UnownedResultOf::AddEnvirons(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(environ)); |
| } |
| |
| Launcher::UnownedResultOf::AddEnvirons Launcher::Call::AddEnvirons(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) { |
| return UnownedResultOf::AddEnvirons(std::move(_client_end), std::move(_request_buffer), std::move(environ)); |
| } |
| |
| ::fidl::internal::StatusAndError Launcher::InPlace::AddEnvirons(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddEnvironsRequest> params) { |
| Launcher::SetTransactionHeaderFor::AddEnvironsRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::internal::StatusAndError::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| zx_status_t _write_status = |
| ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message)); |
| if (_write_status != ZX_OK) { |
| return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed); |
| } else { |
| return ::fidl::internal::StatusAndError(ZX_OK, nullptr); |
| } |
| } |
| |
| |
| Launcher::ResultOf::AddNames_Impl::AddNames_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddNamesRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| AddNamesRequest _request = {}; |
| _request.names = std::move(names); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddNamesRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddNames(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::ResultOf::AddNames Launcher::SyncClient::AddNames(::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) { |
| return ResultOf::AddNames(::zx::unowned_channel(this->channel_), std::move(names)); |
| } |
| |
| Launcher::ResultOf::AddNames Launcher::Call::AddNames(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) { |
| return ResultOf::AddNames(std::move(_client_end), std::move(names)); |
| } |
| |
| |
| Launcher::UnownedResultOf::AddNames_Impl::AddNames_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) { |
| if (_request_buffer.capacity() < AddNamesRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| AddNamesRequest _request = {}; |
| _request.names = std::move(names); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddNamesRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddNames(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::UnownedResultOf::AddNames Launcher::SyncClient::AddNames(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) { |
| return UnownedResultOf::AddNames(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(names)); |
| } |
| |
| Launcher::UnownedResultOf::AddNames Launcher::Call::AddNames(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) { |
| return UnownedResultOf::AddNames(std::move(_client_end), std::move(_request_buffer), std::move(names)); |
| } |
| |
| ::fidl::internal::StatusAndError Launcher::InPlace::AddNames(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddNamesRequest> params) { |
| Launcher::SetTransactionHeaderFor::AddNamesRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::internal::StatusAndError::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| zx_status_t _write_status = |
| ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message)); |
| if (_write_status != ZX_OK) { |
| return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed); |
| } else { |
| return ::fidl::internal::StatusAndError(ZX_OK, nullptr); |
| } |
| } |
| |
| |
| Launcher::ResultOf::AddHandles_Impl::AddHandles_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddHandlesRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| AddHandlesRequest _request = {}; |
| _request.handles = std::move(handles); |
| auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view()); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddHandlesRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddHandles(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::ResultOf::AddHandles Launcher::SyncClient::AddHandles(::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) { |
| return ResultOf::AddHandles(::zx::unowned_channel(this->channel_), std::move(handles)); |
| } |
| |
| Launcher::ResultOf::AddHandles Launcher::Call::AddHandles(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) { |
| return ResultOf::AddHandles(std::move(_client_end), std::move(handles)); |
| } |
| |
| |
| Launcher::UnownedResultOf::AddHandles_Impl::AddHandles_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) { |
| if (_request_buffer.capacity() < AddHandlesRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| AddHandlesRequest _request = {}; |
| _request.handles = std::move(handles); |
| auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer)); |
| if (_linearize_result.status != ZX_OK) { |
| Super::SetFailure(std::move(_linearize_result)); |
| return; |
| } |
| ::fidl::DecodedMessage<AddHandlesRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| Launcher::InPlace::AddHandles(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| Launcher::UnownedResultOf::AddHandles Launcher::SyncClient::AddHandles(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) { |
| return UnownedResultOf::AddHandles(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(handles)); |
| } |
| |
| Launcher::UnownedResultOf::AddHandles Launcher::Call::AddHandles(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) { |
| return UnownedResultOf::AddHandles(std::move(_client_end), std::move(_request_buffer), std::move(handles)); |
| } |
| |
| ::fidl::internal::StatusAndError Launcher::InPlace::AddHandles(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddHandlesRequest> params) { |
| Launcher::SetTransactionHeaderFor::AddHandlesRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::internal::StatusAndError::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| zx_status_t _write_status = |
| ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message)); |
| if (_write_status != ZX_OK) { |
| return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed); |
| } else { |
| return ::fidl::internal::StatusAndError(ZX_OK, nullptr); |
| } |
| } |
| |
| |
| bool Launcher::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 kLauncher_Launch_Ordinal: |
| case kLauncher_Launch_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<LaunchRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->Launch(std::move(message->info), |
| Interface::LaunchCompleter::Sync(txn)); |
| return true; |
| } |
| case kLauncher_CreateWithoutStarting_Ordinal: |
| case kLauncher_CreateWithoutStarting_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<CreateWithoutStartingRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->CreateWithoutStarting(std::move(message->info), |
| Interface::CreateWithoutStartingCompleter::Sync(txn)); |
| return true; |
| } |
| case kLauncher_AddArgs_Ordinal: |
| case kLauncher_AddArgs_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<AddArgsRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->AddArgs(std::move(message->args), |
| Interface::AddArgsCompleter::Sync(txn)); |
| return true; |
| } |
| case kLauncher_AddEnvirons_Ordinal: |
| case kLauncher_AddEnvirons_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<AddEnvironsRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->AddEnvirons(std::move(message->environ), |
| Interface::AddEnvironsCompleter::Sync(txn)); |
| return true; |
| } |
| case kLauncher_AddNames_Ordinal: |
| case kLauncher_AddNames_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<AddNamesRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->AddNames(std::move(message->names), |
| Interface::AddNamesCompleter::Sync(txn)); |
| return true; |
| } |
| case kLauncher_AddHandles_Ordinal: |
| case kLauncher_AddHandles_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<AddHandlesRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->AddHandles(std::move(message->handles), |
| Interface::AddHandlesCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Launcher::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 Launcher::Interface::LaunchCompleterBase::Reply(int32_t status, ::zx::process process) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LaunchResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<LaunchResponse*>(_write_bytes); |
| Launcher::SetTransactionHeaderFor::LaunchResponse( |
| ::fidl::DecodedMessage<LaunchResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| LaunchResponse::PrimarySize, |
| LaunchResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.process = std::move(process); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LaunchResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<LaunchResponse>(std::move(_response_bytes))); |
| } |
| |
| void Launcher::Interface::LaunchCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::process process) { |
| if (_buffer.capacity() < LaunchResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<LaunchResponse*>(_buffer.data()); |
| Launcher::SetTransactionHeaderFor::LaunchResponse( |
| ::fidl::DecodedMessage<LaunchResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| LaunchResponse::PrimarySize, |
| LaunchResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.process = std::move(process); |
| _buffer.set_actual(sizeof(LaunchResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<LaunchResponse>(std::move(_buffer))); |
| } |
| |
| void Launcher::Interface::LaunchCompleterBase::Reply(::fidl::DecodedMessage<LaunchResponse> params) { |
| Launcher::SetTransactionHeaderFor::LaunchResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void Launcher::Interface::CreateWithoutStartingCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::process::ProcessStartData* data) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateWithoutStartingResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize]; |
| CreateWithoutStartingResponse _response = {}; |
| Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse( |
| ::fidl::DecodedMessage<CreateWithoutStartingResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| CreateWithoutStartingResponse::PrimarySize, |
| CreateWithoutStartingResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.data = std::move(data); |
| 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 Launcher::Interface::CreateWithoutStartingCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::process::ProcessStartData* data) { |
| if (_buffer.capacity() < CreateWithoutStartingResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| CreateWithoutStartingResponse _response = {}; |
| Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse( |
| ::fidl::DecodedMessage<CreateWithoutStartingResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| CreateWithoutStartingResponse::PrimarySize, |
| CreateWithoutStartingResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.data = std::move(data); |
| 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 Launcher::Interface::CreateWithoutStartingCompleterBase::Reply(::fidl::DecodedMessage<CreateWithoutStartingResponse> params) { |
| Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void Launcher::SetTransactionHeaderFor::LaunchRequest(const ::fidl::DecodedMessage<Launcher::LaunchRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_Launch_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void Launcher::SetTransactionHeaderFor::LaunchResponse(const ::fidl::DecodedMessage<Launcher::LaunchResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_Launch_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void Launcher::SetTransactionHeaderFor::CreateWithoutStartingRequest(const ::fidl::DecodedMessage<Launcher::CreateWithoutStartingRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_CreateWithoutStarting_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse(const ::fidl::DecodedMessage<Launcher::CreateWithoutStartingResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_CreateWithoutStarting_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void Launcher::SetTransactionHeaderFor::AddArgsRequest(const ::fidl::DecodedMessage<Launcher::AddArgsRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddArgs_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void Launcher::SetTransactionHeaderFor::AddEnvironsRequest(const ::fidl::DecodedMessage<Launcher::AddEnvironsRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddEnvirons_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void Launcher::SetTransactionHeaderFor::AddNamesRequest(const ::fidl::DecodedMessage<Launcher::AddNamesRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddNames_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void Launcher::SetTransactionHeaderFor::AddHandlesRequest(const ::fidl::DecodedMessage<Launcher::AddHandlesRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddHandles_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| } // namespace process |
| } // namespace fuchsia |
| } // namespace llcpp |