| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <fuchsia/exception/llcpp/fidl.h> |
| #include <memory> |
| |
| namespace llcpp { |
| |
| namespace fuchsia { |
| namespace exception { |
| |
| void ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ProcessLimbo_RemoveFilters_Result) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ProcessLimbo_RemoveFilters_Result, ordinal_) == offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ProcessLimbo_RemoveFilters_Result, envelope_) == offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ProcessLimbo_ReleaseProcess_Result) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ProcessLimbo_ReleaseProcess_Result, ordinal_) == offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ProcessLimbo_ReleaseProcess_Result, envelope_) == offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| void ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ProcessLimbo_AppendFilters_Result) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ProcessLimbo_AppendFilters_Result, ordinal_) == offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ProcessLimbo_AppendFilters_Result, envelope_) == offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kHandler_OnException_Ordinal = 0x7ec50e5a00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kHandler_OnException_GenOrdinal = 0x5de09d36098de59elu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionResponseTable; |
| |
| } // namespace |
| template <> |
| Handler::ResultOf::OnException_Impl<Handler::OnExceptionResponse>::OnException_Impl(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnExceptionRequest, ::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, OnExceptionRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<OnExceptionRequest*>(_write_bytes); |
| _request.exception = std::move(exception); |
| _request.info = std::move(info); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnExceptionRequest)); |
| ::fidl::DecodedMessage<OnExceptionRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Handler::InPlace::OnException(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| Handler::ResultOf::OnException Handler::SyncClient::OnException(::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info) { |
| return ResultOf::OnException(::zx::unowned_channel(this->channel_), std::move(exception), std::move(info)); |
| } |
| |
| Handler::ResultOf::OnException Handler::Call::OnException(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info) { |
| return ResultOf::OnException(std::move(_client_end), std::move(exception), std::move(info)); |
| } |
| |
| template <> |
| Handler::UnownedResultOf::OnException_Impl<Handler::OnExceptionResponse>::OnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < OnExceptionRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<OnExceptionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, OnExceptionRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<OnExceptionRequest*>(_request_buffer.data()); |
| _request.exception = std::move(exception); |
| _request.info = std::move(info); |
| _request_buffer.set_actual(sizeof(OnExceptionRequest)); |
| ::fidl::DecodedMessage<OnExceptionRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Handler::InPlace::OnException(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| Handler::UnownedResultOf::OnException Handler::SyncClient::OnException(::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::OnException(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(exception), std::move(info), std::move(_response_buffer)); |
| } |
| |
| Handler::UnownedResultOf::OnException Handler::Call::OnException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::OnException(std::move(_client_end), std::move(_request_buffer), std::move(exception), std::move(info), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Handler::OnExceptionResponse> Handler::InPlace::OnException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnExceptionRequest> params, ::fidl::BytePart response_buffer) { |
| Handler::SetTransactionHeaderFor::OnExceptionRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Handler::OnExceptionResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<OnExceptionRequest, OnExceptionResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Handler::OnExceptionResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool Handler::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 kHandler_OnException_Ordinal: |
| case kHandler_OnException_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<OnExceptionRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->OnException(std::move(message->exception), std::move(message->info), |
| Interface::OnExceptionCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Handler::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 Handler::Interface::OnExceptionCompleterBase::Reply() { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnExceptionResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<OnExceptionResponse*>(_write_bytes); |
| Handler::SetTransactionHeaderFor::OnExceptionResponse( |
| ::fidl::DecodedMessage<OnExceptionResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| OnExceptionResponse::PrimarySize, |
| OnExceptionResponse::PrimarySize))); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnExceptionResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<OnExceptionResponse>(std::move(_response_bytes))); |
| } |
| |
| |
| |
| void Handler::SetTransactionHeaderFor::OnExceptionRequest(const ::fidl::DecodedMessage<Handler::OnExceptionRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kHandler_OnException_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void Handler::SetTransactionHeaderFor::OnExceptionResponse(const ::fidl::DecodedMessage<Handler::OnExceptionResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kHandler_OnException_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| ::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder ProcessExceptionMetadata::Build() { |
| return ProcessExceptionMetadata::Builder(); |
| } |
| |
| auto ::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder::set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[1 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 1) { |
| max_ordinal_ = 1; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder::set_process(::zx::process* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[2 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 2) { |
| max_ordinal_ = 2; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder::set_thread(::zx::thread* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[3 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 3) { |
| max_ordinal_ = 3; |
| } |
| return std::move(*this); |
| } |
| |
| void ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ProcessLimbo_WatchProcessesWaitingOnException_Result) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ProcessLimbo_WatchProcessesWaitingOnException_Result, ordinal_) == offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ProcessLimbo_WatchProcessesWaitingOnException_Result, envelope_) == offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| ::llcpp::fuchsia::exception::ProcessException::Builder ProcessException::Build() { |
| return ProcessException::Builder(); |
| } |
| |
| auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_exception(::zx::exception* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[1 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 1) { |
| max_ordinal_ = 1; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[2 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 2) { |
| max_ordinal_ = 2; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_process(::zx::process* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[3 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 3) { |
| max_ordinal_ = 3; |
| } |
| return std::move(*this); |
| } |
| |
| auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_thread(::zx::thread* elem) -> Builder&& { |
| ZX_ASSERT(elem); |
| envelopes_[4 - 1].data = static_cast<void*>(elem); |
| if (max_ordinal_ < 4) { |
| max_ordinal_ = 4; |
| } |
| return std::move(*this); |
| } |
| |
| void ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(sizeof(ProcessLimbo_RetrieveException_Result) == sizeof(fidl_xunion_t)); |
| static_assert(offsetof(ProcessLimbo_RetrieveException_Result, ordinal_) == offsetof(fidl_xunion_t, tag)); |
| static_assert(offsetof(ProcessLimbo_RetrieveException_Result, envelope_) == offsetof(fidl_xunion_t, envelope)); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_SetActive_Ordinal = 0x1d6dc50c00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_SetActive_GenOrdinal = 0x54c8d03fab29fb35lu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_WatchActive_Ordinal = 0x5400259f00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_WatchActive_GenOrdinal = 0x7b4c6602af289428lu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_WatchProcessesWaitingOnException_Ordinal = 0x5c132e1100000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal = 0xfd5105138d612a3lu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_RetrieveException_Ordinal = 0x47ad466f00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_RetrieveException_GenOrdinal = 0x6ee2df26d6e0444blu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_ReleaseProcess_Ordinal = 0x7adea12100000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_ReleaseProcess_GenOrdinal = 0x76911553fea22b87lu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_AppendFilters_Ordinal = 0x49c3fc8800000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_AppendFilters_GenOrdinal = 0x16a292988604df9alu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_RemoveFilters_Ordinal = 0xfe8829500000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_RemoveFilters_GenOrdinal = 0x1fae63a1df648aelu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_GetFilters_Ordinal = 0x4410733300000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kProcessLimbo_GetFilters_GenOrdinal = 0x11d2a683823e7de6lu; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersRequestTable; |
| extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersResponseTable; |
| |
| } // namespace |
| template <> |
| ProcessLimbo::ResultOf::SetActive_Impl<ProcessLimbo::SetActiveResponse>::SetActive_Impl(::zx::unowned_channel _client_end, bool active) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetActiveRequest, ::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, SetActiveRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SetActiveRequest*>(_write_bytes); |
| _request.active = std::move(active); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetActiveRequest)); |
| ::fidl::DecodedMessage<SetActiveRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::SetActive(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::SetActive ProcessLimbo::SyncClient::SetActive(bool active) { |
| return ResultOf::SetActive(::zx::unowned_channel(this->channel_), std::move(active)); |
| } |
| |
| ProcessLimbo::ResultOf::SetActive ProcessLimbo::Call::SetActive(::zx::unowned_channel _client_end, bool active) { |
| return ResultOf::SetActive(std::move(_client_end), std::move(active)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::SetActive_Impl<ProcessLimbo::SetActiveResponse>::SetActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < SetActiveRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<SetActiveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, SetActiveRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SetActiveRequest*>(_request_buffer.data()); |
| _request.active = std::move(active); |
| _request_buffer.set_actual(sizeof(SetActiveRequest)); |
| ::fidl::DecodedMessage<SetActiveRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::SetActive(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::SetActive ProcessLimbo::SyncClient::SetActive(::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::SetActive(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(active), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::SetActive ProcessLimbo::Call::SetActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::SetActive(std::move(_client_end), std::move(_request_buffer), std::move(active), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::SetActiveResponse> ProcessLimbo::InPlace::SetActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetActiveRequest> params, ::fidl::BytePart response_buffer) { |
| ProcessLimbo::SetTransactionHeaderFor::SetActiveRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::SetActiveResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<SetActiveRequest, SetActiveResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::SetActiveResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| ProcessLimbo::ResultOf::WatchActive_Impl<ProcessLimbo::WatchActiveResponse>::WatchActive_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchActiveRequest, ::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, WatchActiveRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchActiveRequest)); |
| ::fidl::DecodedMessage<WatchActiveRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::WatchActive(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::WatchActive ProcessLimbo::SyncClient::WatchActive() { |
| return ResultOf::WatchActive(::zx::unowned_channel(this->channel_)); |
| } |
| |
| ProcessLimbo::ResultOf::WatchActive ProcessLimbo::Call::WatchActive(::zx::unowned_channel _client_end) { |
| return ResultOf::WatchActive(std::move(_client_end)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::WatchActive_Impl<ProcessLimbo::WatchActiveResponse>::WatchActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchActiveRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, WatchActiveRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(WatchActiveRequest)); |
| ::fidl::DecodedMessage<WatchActiveRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::WatchActive(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::WatchActive ProcessLimbo::SyncClient::WatchActive(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::WatchActive(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::WatchActive ProcessLimbo::Call::WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::WatchActive(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::WatchActiveResponse> ProcessLimbo::InPlace::WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(WatchActiveRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<WatchActiveRequest> params(std::move(_request_buffer)); |
| ProcessLimbo::SetTransactionHeaderFor::WatchActiveRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::WatchActiveResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<WatchActiveRequest, WatchActiveResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::WatchActiveResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| ProcessLimbo::ResultOf::WatchProcessesWaitingOnException_Impl<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchProcessesWaitingOnExceptionRequest, ::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, WatchProcessesWaitingOnExceptionRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchProcessesWaitingOnExceptionRequest)); |
| ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::WatchProcessesWaitingOnException(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::WatchProcessesWaitingOnException ProcessLimbo::SyncClient::WatchProcessesWaitingOnException() { |
| return ResultOf::WatchProcessesWaitingOnException(::zx::unowned_channel(this->channel_)); |
| } |
| |
| ProcessLimbo::ResultOf::WatchProcessesWaitingOnException ProcessLimbo::Call::WatchProcessesWaitingOnException(::zx::unowned_channel _client_end) { |
| return ResultOf::WatchProcessesWaitingOnException(std::move(_client_end)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::WatchProcessesWaitingOnException_Impl<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchProcessesWaitingOnExceptionRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, WatchProcessesWaitingOnExceptionRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(WatchProcessesWaitingOnExceptionRequest)); |
| ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::WatchProcessesWaitingOnException(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::WatchProcessesWaitingOnException ProcessLimbo::SyncClient::WatchProcessesWaitingOnException(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::WatchProcessesWaitingOnException(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::WatchProcessesWaitingOnException ProcessLimbo::Call::WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::WatchProcessesWaitingOnException(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse> ProcessLimbo::InPlace::WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(WatchProcessesWaitingOnExceptionRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionRequest> params(std::move(_request_buffer)); |
| ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<WatchProcessesWaitingOnExceptionRequest, WatchProcessesWaitingOnExceptionResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| ProcessLimbo::ResultOf::RetrieveException_Impl<ProcessLimbo::RetrieveExceptionResponse>::RetrieveException_Impl(::zx::unowned_channel _client_end, uint64_t process_koid) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RetrieveExceptionRequest, ::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, RetrieveExceptionRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<RetrieveExceptionRequest*>(_write_bytes); |
| _request.process_koid = std::move(process_koid); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RetrieveExceptionRequest)); |
| ::fidl::DecodedMessage<RetrieveExceptionRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::RetrieveException(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::RetrieveException ProcessLimbo::SyncClient::RetrieveException(uint64_t process_koid) { |
| return ResultOf::RetrieveException(::zx::unowned_channel(this->channel_), std::move(process_koid)); |
| } |
| |
| ProcessLimbo::ResultOf::RetrieveException ProcessLimbo::Call::RetrieveException(::zx::unowned_channel _client_end, uint64_t process_koid) { |
| return ResultOf::RetrieveException(std::move(_client_end), std::move(process_koid)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::RetrieveException_Impl<ProcessLimbo::RetrieveExceptionResponse>::RetrieveException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < RetrieveExceptionRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<RetrieveExceptionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, RetrieveExceptionRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<RetrieveExceptionRequest*>(_request_buffer.data()); |
| _request.process_koid = std::move(process_koid); |
| _request_buffer.set_actual(sizeof(RetrieveExceptionRequest)); |
| ::fidl::DecodedMessage<RetrieveExceptionRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::RetrieveException(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::RetrieveException ProcessLimbo::SyncClient::RetrieveException(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::RetrieveException(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::RetrieveException ProcessLimbo::Call::RetrieveException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::RetrieveException(std::move(_client_end), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::RetrieveExceptionResponse> ProcessLimbo::InPlace::RetrieveException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RetrieveExceptionRequest> params, ::fidl::BytePart response_buffer) { |
| ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::RetrieveExceptionResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<RetrieveExceptionRequest, RetrieveExceptionResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::RetrieveExceptionResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| ProcessLimbo::ResultOf::ReleaseProcess_Impl<ProcessLimbo::ReleaseProcessResponse>::ReleaseProcess_Impl(::zx::unowned_channel _client_end, uint64_t process_koid) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseProcessRequest, ::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, ReleaseProcessRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<ReleaseProcessRequest*>(_write_bytes); |
| _request.process_koid = std::move(process_koid); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseProcessRequest)); |
| ::fidl::DecodedMessage<ReleaseProcessRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::ReleaseProcess(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::ReleaseProcess ProcessLimbo::SyncClient::ReleaseProcess(uint64_t process_koid) { |
| return ResultOf::ReleaseProcess(::zx::unowned_channel(this->channel_), std::move(process_koid)); |
| } |
| |
| ProcessLimbo::ResultOf::ReleaseProcess ProcessLimbo::Call::ReleaseProcess(::zx::unowned_channel _client_end, uint64_t process_koid) { |
| return ResultOf::ReleaseProcess(std::move(_client_end), std::move(process_koid)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::ReleaseProcess_Impl<ProcessLimbo::ReleaseProcessResponse>::ReleaseProcess_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < ReleaseProcessRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<ReleaseProcessResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, ReleaseProcessRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<ReleaseProcessRequest*>(_request_buffer.data()); |
| _request.process_koid = std::move(process_koid); |
| _request_buffer.set_actual(sizeof(ReleaseProcessRequest)); |
| ::fidl::DecodedMessage<ReleaseProcessRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::ReleaseProcess(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::ReleaseProcess ProcessLimbo::SyncClient::ReleaseProcess(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::ReleaseProcess(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::ReleaseProcess ProcessLimbo::Call::ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::ReleaseProcess(std::move(_client_end), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::ReleaseProcessResponse> ProcessLimbo::InPlace::ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseProcessRequest> params, ::fidl::BytePart response_buffer) { |
| ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::ReleaseProcessResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<ReleaseProcessRequest, ReleaseProcessResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::ReleaseProcessResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| ProcessLimbo::ResultOf::AppendFilters_Impl<ProcessLimbo::AppendFiltersResponse>::AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AppendFiltersRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| AppendFiltersRequest _request = {}; |
| _request.filters = std::move(filters); |
| 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<AppendFiltersRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| ProcessLimbo::InPlace::AppendFilters(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::AppendFilters ProcessLimbo::SyncClient::AppendFilters(::fidl::VectorView<::fidl::StringView> filters) { |
| return ResultOf::AppendFilters(::zx::unowned_channel(this->channel_), std::move(filters)); |
| } |
| |
| ProcessLimbo::ResultOf::AppendFilters ProcessLimbo::Call::AppendFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) { |
| return ResultOf::AppendFilters(std::move(_client_end), std::move(filters)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::AppendFilters_Impl<ProcessLimbo::AppendFiltersResponse>::AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < AppendFiltersRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<AppendFiltersResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| AppendFiltersRequest _request = {}; |
| _request.filters = std::move(filters); |
| 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<AppendFiltersRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| ProcessLimbo::InPlace::AppendFilters(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::AppendFilters ProcessLimbo::SyncClient::AppendFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::AppendFilters(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(filters), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::AppendFilters ProcessLimbo::Call::AppendFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::AppendFilters(std::move(_client_end), std::move(_request_buffer), std::move(filters), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::AppendFiltersResponse> ProcessLimbo::InPlace::AppendFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AppendFiltersRequest> params, ::fidl::BytePart response_buffer) { |
| ProcessLimbo::SetTransactionHeaderFor::AppendFiltersRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::AppendFiltersResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<AppendFiltersRequest, AppendFiltersResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::AppendFiltersResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| ProcessLimbo::ResultOf::RemoveFilters_Impl<ProcessLimbo::RemoveFiltersResponse>::RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveFiltersRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| RemoveFiltersRequest _request = {}; |
| _request.filters = std::move(filters); |
| 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<RemoveFiltersRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| ProcessLimbo::InPlace::RemoveFilters(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::RemoveFilters ProcessLimbo::SyncClient::RemoveFilters(::fidl::VectorView<::fidl::StringView> filters) { |
| return ResultOf::RemoveFilters(::zx::unowned_channel(this->channel_), std::move(filters)); |
| } |
| |
| ProcessLimbo::ResultOf::RemoveFilters ProcessLimbo::Call::RemoveFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) { |
| return ResultOf::RemoveFilters(std::move(_client_end), std::move(filters)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::RemoveFilters_Impl<ProcessLimbo::RemoveFiltersResponse>::RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < RemoveFiltersRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<RemoveFiltersResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| RemoveFiltersRequest _request = {}; |
| _request.filters = std::move(filters); |
| 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<RemoveFiltersRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| ProcessLimbo::InPlace::RemoveFilters(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::RemoveFilters ProcessLimbo::SyncClient::RemoveFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::RemoveFilters(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(filters), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::RemoveFilters ProcessLimbo::Call::RemoveFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::RemoveFilters(std::move(_client_end), std::move(_request_buffer), std::move(filters), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::RemoveFiltersResponse> ProcessLimbo::InPlace::RemoveFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveFiltersRequest> params, ::fidl::BytePart response_buffer) { |
| ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::RemoveFiltersResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<RemoveFiltersRequest, RemoveFiltersResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::RemoveFiltersResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| ProcessLimbo::ResultOf::GetFilters_Impl<ProcessLimbo::GetFiltersResponse>::GetFilters_Impl(::zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFiltersRequest, ::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, GetFiltersRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFiltersRequest)); |
| ::fidl::DecodedMessage<GetFiltersRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::GetFilters(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| ProcessLimbo::ResultOf::GetFilters ProcessLimbo::SyncClient::GetFilters() { |
| return ResultOf::GetFilters(::zx::unowned_channel(this->channel_)); |
| } |
| |
| ProcessLimbo::ResultOf::GetFilters ProcessLimbo::Call::GetFilters(::zx::unowned_channel _client_end) { |
| return ResultOf::GetFilters(std::move(_client_end)); |
| } |
| |
| template <> |
| ProcessLimbo::UnownedResultOf::GetFilters_Impl<ProcessLimbo::GetFiltersResponse>::GetFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFiltersRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, GetFiltersRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(GetFiltersRequest)); |
| ::fidl::DecodedMessage<GetFiltersRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| ProcessLimbo::InPlace::GetFilters(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| ProcessLimbo::UnownedResultOf::GetFilters ProcessLimbo::SyncClient::GetFilters(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetFilters(::zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| ProcessLimbo::UnownedResultOf::GetFilters ProcessLimbo::Call::GetFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::GetFilters(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<ProcessLimbo::GetFiltersResponse> ProcessLimbo::InPlace::GetFilters(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(GetFiltersRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<GetFiltersRequest> params(std::move(_request_buffer)); |
| ProcessLimbo::SetTransactionHeaderFor::GetFiltersRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::GetFiltersResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<GetFiltersRequest, GetFiltersResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<ProcessLimbo::GetFiltersResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool ProcessLimbo::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 kProcessLimbo_SetActive_Ordinal: |
| case kProcessLimbo_SetActive_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<SetActiveRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->SetActive(std::move(message->active), |
| Interface::SetActiveCompleter::Sync(txn)); |
| return true; |
| } |
| case kProcessLimbo_WatchActive_Ordinal: |
| case kProcessLimbo_WatchActive_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<WatchActiveRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->WatchActive( |
| Interface::WatchActiveCompleter::Sync(txn)); |
| return true; |
| } |
| case kProcessLimbo_WatchProcessesWaitingOnException_Ordinal: |
| case kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<WatchProcessesWaitingOnExceptionRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->WatchProcessesWaitingOnException( |
| Interface::WatchProcessesWaitingOnExceptionCompleter::Sync(txn)); |
| return true; |
| } |
| case kProcessLimbo_RetrieveException_Ordinal: |
| case kProcessLimbo_RetrieveException_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<RetrieveExceptionRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->RetrieveException(std::move(message->process_koid), |
| Interface::RetrieveExceptionCompleter::Sync(txn)); |
| return true; |
| } |
| case kProcessLimbo_ReleaseProcess_Ordinal: |
| case kProcessLimbo_ReleaseProcess_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<ReleaseProcessRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->ReleaseProcess(std::move(message->process_koid), |
| Interface::ReleaseProcessCompleter::Sync(txn)); |
| return true; |
| } |
| case kProcessLimbo_AppendFilters_Ordinal: |
| case kProcessLimbo_AppendFilters_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<AppendFiltersRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->AppendFilters(std::move(message->filters), |
| Interface::AppendFiltersCompleter::Sync(txn)); |
| return true; |
| } |
| case kProcessLimbo_RemoveFilters_Ordinal: |
| case kProcessLimbo_RemoveFilters_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<RemoveFiltersRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->RemoveFilters(std::move(message->filters), |
| Interface::RemoveFiltersCompleter::Sync(txn)); |
| return true; |
| } |
| case kProcessLimbo_GetFilters_Ordinal: |
| case kProcessLimbo_GetFilters_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<GetFiltersRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| impl->GetFilters( |
| Interface::GetFiltersCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool ProcessLimbo::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 ProcessLimbo::Interface::SetActiveCompleterBase::Reply() { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetActiveResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<SetActiveResponse*>(_write_bytes); |
| ProcessLimbo::SetTransactionHeaderFor::SetActiveResponse( |
| ::fidl::DecodedMessage<SetActiveResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| SetActiveResponse::PrimarySize, |
| SetActiveResponse::PrimarySize))); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetActiveResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<SetActiveResponse>(std::move(_response_bytes))); |
| } |
| |
| |
| void ProcessLimbo::Interface::WatchActiveCompleterBase::Reply(bool is_active) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchActiveResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<WatchActiveResponse*>(_write_bytes); |
| ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse( |
| ::fidl::DecodedMessage<WatchActiveResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| WatchActiveResponse::PrimarySize, |
| WatchActiveResponse::PrimarySize))); |
| _response.is_active = std::move(is_active); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchActiveResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<WatchActiveResponse>(std::move(_response_bytes))); |
| } |
| |
| void ProcessLimbo::Interface::WatchActiveCompleterBase::Reply(::fidl::BytePart _buffer, bool is_active) { |
| if (_buffer.capacity() < WatchActiveResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<WatchActiveResponse*>(_buffer.data()); |
| ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse( |
| ::fidl::DecodedMessage<WatchActiveResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| WatchActiveResponse::PrimarySize, |
| WatchActiveResponse::PrimarySize))); |
| _response.is_active = std::move(is_active); |
| _buffer.set_actual(sizeof(WatchActiveResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<WatchActiveResponse>(std::move(_buffer))); |
| } |
| |
| void ProcessLimbo::Interface::WatchActiveCompleterBase::Reply(::fidl::DecodedMessage<WatchActiveResponse> params) { |
| ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchProcessesWaitingOnExceptionResponse, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]); |
| uint8_t* _write_bytes = _write_bytes_unique_ptr.get(); |
| WatchProcessesWaitingOnExceptionResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse( |
| ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| WatchProcessesWaitingOnExceptionResponse::PrimarySize, |
| WatchProcessesWaitingOnExceptionResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::ReplySuccess(::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list) { |
| ProcessLimbo_WatchProcessesWaitingOnException_Response response; |
| response.exception_list = std::move(exception_list); |
| |
| Reply(ProcessLimbo_WatchProcessesWaitingOnException_Result::WithResponse(&response)); |
| } |
| void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::ReplyError(int32_t error) { |
| Reply(ProcessLimbo_WatchProcessesWaitingOnException_Result::WithErr(&error)); |
| } |
| |
| void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result) { |
| if (_buffer.capacity() < WatchProcessesWaitingOnExceptionResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| WatchProcessesWaitingOnExceptionResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse( |
| ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| WatchProcessesWaitingOnExceptionResponse::PrimarySize, |
| WatchProcessesWaitingOnExceptionResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list) { |
| ProcessLimbo_WatchProcessesWaitingOnException_Response response; |
| response.exception_list = std::move(exception_list); |
| |
| Reply(std::move(_buffer), ProcessLimbo_WatchProcessesWaitingOnException_Result::WithResponse(&response)); |
| } |
| |
| void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::Reply(::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse> params) { |
| ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RetrieveExceptionResponse, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]); |
| uint8_t* _write_bytes = _write_bytes_unique_ptr.get(); |
| RetrieveExceptionResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse( |
| ::fidl::DecodedMessage<RetrieveExceptionResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| RetrieveExceptionResponse::PrimarySize, |
| RetrieveExceptionResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::RetrieveExceptionCompleterBase::ReplySuccess(::llcpp::fuchsia::exception::ProcessException process_exception) { |
| ProcessLimbo_RetrieveException_Response response; |
| response.process_exception = std::move(process_exception); |
| |
| Reply(ProcessLimbo_RetrieveException_Result::WithResponse(&response)); |
| } |
| void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::ReplyError(int32_t error) { |
| Reply(ProcessLimbo_RetrieveException_Result::WithErr(&error)); |
| } |
| |
| void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result) { |
| if (_buffer.capacity() < RetrieveExceptionResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| RetrieveExceptionResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse( |
| ::fidl::DecodedMessage<RetrieveExceptionResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| RetrieveExceptionResponse::PrimarySize, |
| RetrieveExceptionResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::RetrieveExceptionCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessException process_exception) { |
| ProcessLimbo_RetrieveException_Response response; |
| response.process_exception = std::move(process_exception); |
| |
| Reply(std::move(_buffer), ProcessLimbo_RetrieveException_Result::WithResponse(&response)); |
| } |
| |
| void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::Reply(::fidl::DecodedMessage<RetrieveExceptionResponse> params) { |
| ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void ProcessLimbo::Interface::ReleaseProcessCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseProcessResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize]; |
| ReleaseProcessResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse( |
| ::fidl::DecodedMessage<ReleaseProcessResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| ReleaseProcessResponse::PrimarySize, |
| ReleaseProcessResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::ReleaseProcessCompleterBase::ReplySuccess() { |
| ProcessLimbo_ReleaseProcess_Response response; |
| |
| Reply(ProcessLimbo_ReleaseProcess_Result::WithResponse(&response)); |
| } |
| void ProcessLimbo::Interface::ReleaseProcessCompleterBase::ReplyError(int32_t error) { |
| Reply(ProcessLimbo_ReleaseProcess_Result::WithErr(&error)); |
| } |
| |
| void ProcessLimbo::Interface::ReleaseProcessCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result) { |
| if (_buffer.capacity() < ReleaseProcessResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| ReleaseProcessResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse( |
| ::fidl::DecodedMessage<ReleaseProcessResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| ReleaseProcessResponse::PrimarySize, |
| ReleaseProcessResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::ReleaseProcessCompleterBase::ReplySuccess(::fidl::BytePart _buffer) { |
| ProcessLimbo_ReleaseProcess_Response response; |
| |
| Reply(std::move(_buffer), ProcessLimbo_ReleaseProcess_Result::WithResponse(&response)); |
| } |
| |
| void ProcessLimbo::Interface::ReleaseProcessCompleterBase::Reply(::fidl::DecodedMessage<ReleaseProcessResponse> params) { |
| ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void ProcessLimbo::Interface::AppendFiltersCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AppendFiltersResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize]; |
| AppendFiltersResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse( |
| ::fidl::DecodedMessage<AppendFiltersResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| AppendFiltersResponse::PrimarySize, |
| AppendFiltersResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::AppendFiltersCompleterBase::ReplySuccess() { |
| ProcessLimbo_AppendFilters_Response response; |
| |
| Reply(ProcessLimbo_AppendFilters_Result::WithResponse(&response)); |
| } |
| void ProcessLimbo::Interface::AppendFiltersCompleterBase::ReplyError(int32_t error) { |
| Reply(ProcessLimbo_AppendFilters_Result::WithErr(&error)); |
| } |
| |
| void ProcessLimbo::Interface::AppendFiltersCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result) { |
| if (_buffer.capacity() < AppendFiltersResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| AppendFiltersResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse( |
| ::fidl::DecodedMessage<AppendFiltersResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| AppendFiltersResponse::PrimarySize, |
| AppendFiltersResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::AppendFiltersCompleterBase::ReplySuccess(::fidl::BytePart _buffer) { |
| ProcessLimbo_AppendFilters_Response response; |
| |
| Reply(std::move(_buffer), ProcessLimbo_AppendFilters_Result::WithResponse(&response)); |
| } |
| |
| void ProcessLimbo::Interface::AppendFiltersCompleterBase::Reply(::fidl::DecodedMessage<AppendFiltersResponse> params) { |
| ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void ProcessLimbo::Interface::RemoveFiltersCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveFiltersResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize]; |
| RemoveFiltersResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse( |
| ::fidl::DecodedMessage<RemoveFiltersResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| RemoveFiltersResponse::PrimarySize, |
| RemoveFiltersResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::RemoveFiltersCompleterBase::ReplySuccess() { |
| ProcessLimbo_RemoveFilters_Response response; |
| |
| Reply(ProcessLimbo_RemoveFilters_Result::WithResponse(&response)); |
| } |
| void ProcessLimbo::Interface::RemoveFiltersCompleterBase::ReplyError(int32_t error) { |
| Reply(ProcessLimbo_RemoveFilters_Result::WithErr(&error)); |
| } |
| |
| void ProcessLimbo::Interface::RemoveFiltersCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result) { |
| if (_buffer.capacity() < RemoveFiltersResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| RemoveFiltersResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse( |
| ::fidl::DecodedMessage<RemoveFiltersResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| RemoveFiltersResponse::PrimarySize, |
| RemoveFiltersResponse::PrimarySize))); |
| _response.result = std::move(result); |
| 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 ProcessLimbo::Interface::RemoveFiltersCompleterBase::ReplySuccess(::fidl::BytePart _buffer) { |
| ProcessLimbo_RemoveFilters_Response response; |
| |
| Reply(std::move(_buffer), ProcessLimbo_RemoveFilters_Result::WithResponse(&response)); |
| } |
| |
| void ProcessLimbo::Interface::RemoveFiltersCompleterBase::Reply(::fidl::DecodedMessage<RemoveFiltersResponse> params) { |
| ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void ProcessLimbo::Interface::GetFiltersCompleterBase::Reply(::fidl::VectorView<::fidl::StringView> filters) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFiltersResponse, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]); |
| uint8_t* _write_bytes = _write_bytes_unique_ptr.get(); |
| GetFiltersResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse( |
| ::fidl::DecodedMessage<GetFiltersResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetFiltersResponse::PrimarySize, |
| GetFiltersResponse::PrimarySize))); |
| _response.filters = std::move(filters); |
| 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 ProcessLimbo::Interface::GetFiltersCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::fidl::StringView> filters) { |
| if (_buffer.capacity() < GetFiltersResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| GetFiltersResponse _response = {}; |
| ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse( |
| ::fidl::DecodedMessage<GetFiltersResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| GetFiltersResponse::PrimarySize, |
| GetFiltersResponse::PrimarySize))); |
| _response.filters = std::move(filters); |
| 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 ProcessLimbo::Interface::GetFiltersCompleterBase::Reply(::fidl::DecodedMessage<GetFiltersResponse> params) { |
| ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void ProcessLimbo::SetTransactionHeaderFor::SetActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_SetActive_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::SetActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_SetActive_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void ProcessLimbo::SetTransactionHeaderFor::WatchActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchActive_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchActive_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RetrieveException_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RetrieveException_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessRequest(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_ReleaseProcess_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_ReleaseProcess_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void ProcessLimbo::SetTransactionHeaderFor::AppendFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_AppendFilters_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_AppendFilters_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RemoveFilters_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RemoveFilters_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| void ProcessLimbo::SetTransactionHeaderFor::GetFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_GetFilters_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| void ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_GetFilters_GenOrdinal); |
| _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG; |
| } |
| |
| } // namespace exception |
| } // namespace fuchsia |
| } // namespace llcpp |
