| // WARNING: This file is machine generated by fidlgen. |
| |
| #include <fuchsia/device/manager/llcpp/fidl.h> |
| #include <memory> |
| |
| namespace llcpp { |
| |
| namespace fuchsia { |
| namespace device { |
| namespace manager { |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kDebugDumper_DumpTree_Ordinal = 0x3804588c00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugDumper_DumpTree_GenOrdinal = 0x2985d961d4cd5c04lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpTreeRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpTreeResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpTreeResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugDumper_DumpDrivers_Ordinal = 0x5237dc7300000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugDumper_DumpDrivers_GenOrdinal = 0x1cbb832b151a378lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpDriversRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpDriversResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpDriversResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugDumper_DumpBindingProperties_Ordinal = 0x1954f6f100000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDebugDumper_DumpBindingProperties_GenOrdinal = 0x15b8794479ed66edlu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable; |
| |
| } // namespace |
| template <> |
| DebugDumper::ResultOf::DumpTree_Impl<DebugDumper::DumpTreeResponse>::DumpTree_Impl(zx::unowned_channel _client_end, ::zx::vmo output) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpTreeRequest, ::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, DumpTreeRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<DumpTreeRequest*>(_write_bytes); |
| _request.output = std::move(output); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpTreeRequest)); |
| ::fidl::DecodedMessage<DumpTreeRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DebugDumper::InPlace::DumpTree(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DebugDumper::ResultOf::DumpTree DebugDumper::SyncClient::DumpTree(::zx::vmo output) { |
| return ResultOf::DumpTree(zx::unowned_channel(this->channel_), std::move(output)); |
| } |
| |
| DebugDumper::ResultOf::DumpTree DebugDumper::Call::DumpTree(zx::unowned_channel _client_end, ::zx::vmo output) { |
| return ResultOf::DumpTree(std::move(_client_end), std::move(output)); |
| } |
| |
| template <> |
| DebugDumper::UnownedResultOf::DumpTree_Impl<DebugDumper::DumpTreeResponse>::DumpTree_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < DumpTreeRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<DumpTreeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, DumpTreeRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<DumpTreeRequest*>(_request_buffer.data()); |
| _request.output = std::move(output); |
| _request_buffer.set_actual(sizeof(DumpTreeRequest)); |
| ::fidl::DecodedMessage<DumpTreeRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| DebugDumper::InPlace::DumpTree(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DebugDumper::UnownedResultOf::DumpTree DebugDumper::SyncClient::DumpTree(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::DumpTree(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer)); |
| } |
| |
| DebugDumper::UnownedResultOf::DumpTree DebugDumper::Call::DumpTree(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::DumpTree(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DebugDumper::DumpTreeResponse> DebugDumper::InPlace::DumpTree(zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpTreeRequest> params, ::fidl::BytePart response_buffer) { |
| DebugDumper::SetTransactionHeaderFor::DumpTreeRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugDumper::DumpTreeResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<DumpTreeRequest, DumpTreeResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugDumper::DumpTreeResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| DebugDumper::ResultOf::DumpDrivers_Impl<DebugDumper::DumpDriversResponse>::DumpDrivers_Impl(zx::unowned_channel _client_end, ::zx::vmo output) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpDriversRequest, ::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, DumpDriversRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<DumpDriversRequest*>(_write_bytes); |
| _request.output = std::move(output); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpDriversRequest)); |
| ::fidl::DecodedMessage<DumpDriversRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DebugDumper::InPlace::DumpDrivers(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DebugDumper::ResultOf::DumpDrivers DebugDumper::SyncClient::DumpDrivers(::zx::vmo output) { |
| return ResultOf::DumpDrivers(zx::unowned_channel(this->channel_), std::move(output)); |
| } |
| |
| DebugDumper::ResultOf::DumpDrivers DebugDumper::Call::DumpDrivers(zx::unowned_channel _client_end, ::zx::vmo output) { |
| return ResultOf::DumpDrivers(std::move(_client_end), std::move(output)); |
| } |
| |
| template <> |
| DebugDumper::UnownedResultOf::DumpDrivers_Impl<DebugDumper::DumpDriversResponse>::DumpDrivers_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < DumpDriversRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<DumpDriversResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, DumpDriversRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<DumpDriversRequest*>(_request_buffer.data()); |
| _request.output = std::move(output); |
| _request_buffer.set_actual(sizeof(DumpDriversRequest)); |
| ::fidl::DecodedMessage<DumpDriversRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| DebugDumper::InPlace::DumpDrivers(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DebugDumper::UnownedResultOf::DumpDrivers DebugDumper::SyncClient::DumpDrivers(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::DumpDrivers(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer)); |
| } |
| |
| DebugDumper::UnownedResultOf::DumpDrivers DebugDumper::Call::DumpDrivers(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::DumpDrivers(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DebugDumper::DumpDriversResponse> DebugDumper::InPlace::DumpDrivers(zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpDriversRequest> params, ::fidl::BytePart response_buffer) { |
| DebugDumper::SetTransactionHeaderFor::DumpDriversRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugDumper::DumpDriversResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<DumpDriversRequest, DumpDriversResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugDumper::DumpDriversResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| DebugDumper::ResultOf::DumpBindingProperties_Impl<DebugDumper::DumpBindingPropertiesResponse>::DumpBindingProperties_Impl(zx::unowned_channel _client_end, ::zx::vmo output) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpBindingPropertiesRequest, ::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, DumpBindingPropertiesRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<DumpBindingPropertiesRequest*>(_write_bytes); |
| _request.output = std::move(output); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpBindingPropertiesRequest)); |
| ::fidl::DecodedMessage<DumpBindingPropertiesRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DebugDumper::InPlace::DumpBindingProperties(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DebugDumper::ResultOf::DumpBindingProperties DebugDumper::SyncClient::DumpBindingProperties(::zx::vmo output) { |
| return ResultOf::DumpBindingProperties(zx::unowned_channel(this->channel_), std::move(output)); |
| } |
| |
| DebugDumper::ResultOf::DumpBindingProperties DebugDumper::Call::DumpBindingProperties(zx::unowned_channel _client_end, ::zx::vmo output) { |
| return ResultOf::DumpBindingProperties(std::move(_client_end), std::move(output)); |
| } |
| |
| template <> |
| DebugDumper::UnownedResultOf::DumpBindingProperties_Impl<DebugDumper::DumpBindingPropertiesResponse>::DumpBindingProperties_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < DumpBindingPropertiesRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<DumpBindingPropertiesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, DumpBindingPropertiesRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<DumpBindingPropertiesRequest*>(_request_buffer.data()); |
| _request.output = std::move(output); |
| _request_buffer.set_actual(sizeof(DumpBindingPropertiesRequest)); |
| ::fidl::DecodedMessage<DumpBindingPropertiesRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| DebugDumper::InPlace::DumpBindingProperties(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DebugDumper::UnownedResultOf::DumpBindingProperties DebugDumper::SyncClient::DumpBindingProperties(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::DumpBindingProperties(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer)); |
| } |
| |
| DebugDumper::UnownedResultOf::DumpBindingProperties DebugDumper::Call::DumpBindingProperties(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::DumpBindingProperties(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse> DebugDumper::InPlace::DumpBindingProperties(zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpBindingPropertiesRequest> params, ::fidl::BytePart response_buffer) { |
| DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<DumpBindingPropertiesRequest, DumpBindingPropertiesResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool DebugDumper::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 kDebugDumper_DumpTree_Ordinal: |
| case kDebugDumper_DumpTree_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<DumpTreeRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->DumpTree(std::move(message->output), |
| Interface::DumpTreeCompleter::Sync(txn)); |
| return true; |
| } |
| case kDebugDumper_DumpDrivers_Ordinal: |
| case kDebugDumper_DumpDrivers_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<DumpDriversRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->DumpDrivers(std::move(message->output), |
| Interface::DumpDriversCompleter::Sync(txn)); |
| return true; |
| } |
| case kDebugDumper_DumpBindingProperties_Ordinal: |
| case kDebugDumper_DumpBindingProperties_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<DumpBindingPropertiesRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->DumpBindingProperties(std::move(message->output), |
| Interface::DumpBindingPropertiesCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool DebugDumper::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 DebugDumper::Interface::DumpTreeCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpTreeResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<DumpTreeResponse*>(_write_bytes); |
| DebugDumper::SetTransactionHeaderFor::DumpTreeResponse( |
| ::fidl::DecodedMessage<DumpTreeResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| DumpTreeResponse::PrimarySize, |
| DumpTreeResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.written = std::move(written); |
| _response.available = std::move(available); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpTreeResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<DumpTreeResponse>(std::move(_response_bytes))); |
| } |
| |
| void DebugDumper::Interface::DumpTreeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) { |
| if (_buffer.capacity() < DumpTreeResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<DumpTreeResponse*>(_buffer.data()); |
| DebugDumper::SetTransactionHeaderFor::DumpTreeResponse( |
| ::fidl::DecodedMessage<DumpTreeResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| DumpTreeResponse::PrimarySize, |
| DumpTreeResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.written = std::move(written); |
| _response.available = std::move(available); |
| _buffer.set_actual(sizeof(DumpTreeResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<DumpTreeResponse>(std::move(_buffer))); |
| } |
| |
| void DebugDumper::Interface::DumpTreeCompleterBase::Reply(::fidl::DecodedMessage<DumpTreeResponse> params) { |
| DebugDumper::SetTransactionHeaderFor::DumpTreeResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void DebugDumper::Interface::DumpDriversCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpDriversResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<DumpDriversResponse*>(_write_bytes); |
| DebugDumper::SetTransactionHeaderFor::DumpDriversResponse( |
| ::fidl::DecodedMessage<DumpDriversResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| DumpDriversResponse::PrimarySize, |
| DumpDriversResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.written = std::move(written); |
| _response.available = std::move(available); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpDriversResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<DumpDriversResponse>(std::move(_response_bytes))); |
| } |
| |
| void DebugDumper::Interface::DumpDriversCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) { |
| if (_buffer.capacity() < DumpDriversResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<DumpDriversResponse*>(_buffer.data()); |
| DebugDumper::SetTransactionHeaderFor::DumpDriversResponse( |
| ::fidl::DecodedMessage<DumpDriversResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| DumpDriversResponse::PrimarySize, |
| DumpDriversResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.written = std::move(written); |
| _response.available = std::move(available); |
| _buffer.set_actual(sizeof(DumpDriversResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<DumpDriversResponse>(std::move(_buffer))); |
| } |
| |
| void DebugDumper::Interface::DumpDriversCompleterBase::Reply(::fidl::DecodedMessage<DumpDriversResponse> params) { |
| DebugDumper::SetTransactionHeaderFor::DumpDriversResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpBindingPropertiesResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<DumpBindingPropertiesResponse*>(_write_bytes); |
| DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse( |
| ::fidl::DecodedMessage<DumpBindingPropertiesResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| DumpBindingPropertiesResponse::PrimarySize, |
| DumpBindingPropertiesResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.written = std::move(written); |
| _response.available = std::move(available); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpBindingPropertiesResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<DumpBindingPropertiesResponse>(std::move(_response_bytes))); |
| } |
| |
| void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) { |
| if (_buffer.capacity() < DumpBindingPropertiesResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<DumpBindingPropertiesResponse*>(_buffer.data()); |
| DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse( |
| ::fidl::DecodedMessage<DumpBindingPropertiesResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| DumpBindingPropertiesResponse::PrimarySize, |
| DumpBindingPropertiesResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _response.written = std::move(written); |
| _response.available = std::move(available); |
| _buffer.set_actual(sizeof(DumpBindingPropertiesResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<DumpBindingPropertiesResponse>(std::move(_buffer))); |
| } |
| |
| void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(::fidl::DecodedMessage<DumpBindingPropertiesResponse> params) { |
| DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void DebugDumper::SetTransactionHeaderFor::DumpTreeRequest(const ::fidl::DecodedMessage<DebugDumper::DumpTreeRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpTree_GenOrdinal); |
| } |
| void DebugDumper::SetTransactionHeaderFor::DumpTreeResponse(const ::fidl::DecodedMessage<DebugDumper::DumpTreeResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpTree_GenOrdinal); |
| } |
| |
| void DebugDumper::SetTransactionHeaderFor::DumpDriversRequest(const ::fidl::DecodedMessage<DebugDumper::DumpDriversRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpDrivers_GenOrdinal); |
| } |
| void DebugDumper::SetTransactionHeaderFor::DumpDriversResponse(const ::fidl::DecodedMessage<DebugDumper::DumpDriversResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpDrivers_GenOrdinal); |
| } |
| |
| void DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesRequest(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpBindingProperties_GenOrdinal); |
| } |
| void DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpBindingProperties_GenOrdinal); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kAdministrator_Suspend_Ordinal = 0x7ecaa18c00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kAdministrator_Suspend_GenOrdinal = 0x4bb44c32133da26elu; |
| extern "C" const fidl_type_t fuchsia_device_manager_AdministratorSuspendRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_AdministratorSuspendResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_AdministratorSuspendResponseTable; |
| |
| } // namespace |
| template <> |
| Administrator::ResultOf::Suspend_Impl<Administrator::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, uint32_t flags) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::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, SuspendRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes); |
| _request.flags = std::move(flags); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest)); |
| ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| Administrator::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| Administrator::ResultOf::Suspend Administrator::SyncClient::Suspend(uint32_t flags) { |
| return ResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(flags)); |
| } |
| |
| Administrator::ResultOf::Suspend Administrator::Call::Suspend(zx::unowned_channel _client_end, uint32_t flags) { |
| return ResultOf::Suspend(std::move(_client_end), std::move(flags)); |
| } |
| |
| template <> |
| Administrator::UnownedResultOf::Suspend_Impl<Administrator::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < SuspendRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data()); |
| _request.flags = std::move(flags); |
| _request_buffer.set_actual(sizeof(SuspendRequest)); |
| ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| Administrator::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| Administrator::UnownedResultOf::Suspend Administrator::SyncClient::Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer)); |
| } |
| |
| Administrator::UnownedResultOf::Suspend Administrator::Call::Suspend(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<Administrator::SuspendResponse> Administrator::InPlace::Suspend(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) { |
| Administrator::SetTransactionHeaderFor::SuspendRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Administrator::SuspendResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<Administrator::SuspendResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool Administrator::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 kAdministrator_Suspend_Ordinal: |
| case kAdministrator_Suspend_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<SuspendRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->Suspend(std::move(message->flags), |
| Interface::SuspendCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool Administrator::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 Administrator::Interface::SuspendCompleterBase::Reply(int32_t status) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<SuspendResponse*>(_write_bytes); |
| Administrator::SetTransactionHeaderFor::SuspendResponse( |
| ::fidl::DecodedMessage<SuspendResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| SuspendResponse::PrimarySize, |
| SuspendResponse::PrimarySize))); |
| _response.status = std::move(status); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_response_bytes))); |
| } |
| |
| void Administrator::Interface::SuspendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) { |
| if (_buffer.capacity() < SuspendResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<SuspendResponse*>(_buffer.data()); |
| Administrator::SetTransactionHeaderFor::SuspendResponse( |
| ::fidl::DecodedMessage<SuspendResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| SuspendResponse::PrimarySize, |
| SuspendResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _buffer.set_actual(sizeof(SuspendResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_buffer))); |
| } |
| |
| void Administrator::Interface::SuspendCompleterBase::Reply(::fidl::DecodedMessage<SuspendResponse> params) { |
| Administrator::SetTransactionHeaderFor::SuspendResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void Administrator::SetTransactionHeaderFor::SuspendRequest(const ::fidl::DecodedMessage<Administrator::SuspendRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdministrator_Suspend_GenOrdinal); |
| } |
| void Administrator::SetTransactionHeaderFor::SuspendResponse(const ::fidl::DecodedMessage<Administrator::SuspendResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdministrator_Suspend_GenOrdinal); |
| } |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kDevhostController_CreateDeviceStub_Ordinal = 0x2d8e104b00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDevhostController_CreateDeviceStub_GenOrdinal = 0x62409c9e94ff9699lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceStubResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDevhostController_CreateDevice_Ordinal = 0x2f6f95b700000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDevhostController_CreateDevice_GenOrdinal = 0x7dbabaee2c92e2c6lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateDeviceResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDevhostController_CreateCompositeDevice_Ordinal = 0x358e5a0900000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDevhostController_CreateCompositeDevice_GenOrdinal = 0x1d0ddbfd4f798c80lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable; |
| |
| } // namespace |
| |
| DevhostController::ResultOf::CreateDeviceStub_Impl::CreateDeviceStub_Impl(zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateDeviceStubRequest, ::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, CreateDeviceStubRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<CreateDeviceStubRequest*>(_write_bytes); |
| _request.coordinator_rpc = std::move(coordinator_rpc); |
| _request.device_controller_rpc = std::move(device_controller_rpc); |
| _request.protocol_id = std::move(protocol_id); |
| _request.local_device_id = std::move(local_device_id); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateDeviceStubRequest)); |
| ::fidl::DecodedMessage<CreateDeviceStubRequest> _decoded_request(std::move(_request_bytes)); |
| Super::operator=( |
| DevhostController::InPlace::CreateDeviceStub(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| DevhostController::ResultOf::CreateDeviceStub DevhostController::SyncClient::CreateDeviceStub(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) { |
| return ResultOf::CreateDeviceStub(zx::unowned_channel(this->channel_), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id)); |
| } |
| |
| DevhostController::ResultOf::CreateDeviceStub DevhostController::Call::CreateDeviceStub(zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) { |
| return ResultOf::CreateDeviceStub(std::move(_client_end), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id)); |
| } |
| |
| |
| DevhostController::UnownedResultOf::CreateDeviceStub_Impl::CreateDeviceStub_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) { |
| if (_request_buffer.capacity() < CreateDeviceStubRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| memset(_request_buffer.data(), 0, CreateDeviceStubRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<CreateDeviceStubRequest*>(_request_buffer.data()); |
| _request.coordinator_rpc = std::move(coordinator_rpc); |
| _request.device_controller_rpc = std::move(device_controller_rpc); |
| _request.protocol_id = std::move(protocol_id); |
| _request.local_device_id = std::move(local_device_id); |
| _request_buffer.set_actual(sizeof(CreateDeviceStubRequest)); |
| ::fidl::DecodedMessage<CreateDeviceStubRequest> _decoded_request(std::move(_request_buffer)); |
| Super::operator=( |
| DevhostController::InPlace::CreateDeviceStub(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| DevhostController::UnownedResultOf::CreateDeviceStub DevhostController::SyncClient::CreateDeviceStub(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) { |
| return UnownedResultOf::CreateDeviceStub(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id)); |
| } |
| |
| DevhostController::UnownedResultOf::CreateDeviceStub DevhostController::Call::CreateDeviceStub(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) { |
| return UnownedResultOf::CreateDeviceStub(std::move(_client_end), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id)); |
| } |
| |
| ::fidl::internal::StatusAndError DevhostController::InPlace::CreateDeviceStub(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceStubRequest> params) { |
| DevhostController::SetTransactionHeaderFor::CreateDeviceStubRequest(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); |
| } |
| } |
| |
| |
| DevhostController::ResultOf::CreateDevice_Impl::CreateDevice_Impl(zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateDeviceRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| CreateDeviceRequest _request = {}; |
| _request.coordinator_rpc = std::move(coordinator_rpc); |
| _request.device_controller_rpc = std::move(device_controller_rpc); |
| _request.driver_path = std::move(driver_path); |
| _request.driver = std::move(driver); |
| _request.parent_proxy = std::move(parent_proxy); |
| _request.proxy_args = std::move(proxy_args); |
| _request.local_device_id = std::move(local_device_id); |
| 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<CreateDeviceRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| DevhostController::InPlace::CreateDevice(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| DevhostController::ResultOf::CreateDevice DevhostController::SyncClient::CreateDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) { |
| return ResultOf::CreateDevice(zx::unowned_channel(this->channel_), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id)); |
| } |
| |
| DevhostController::ResultOf::CreateDevice DevhostController::Call::CreateDevice(zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) { |
| return ResultOf::CreateDevice(std::move(_client_end), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id)); |
| } |
| |
| |
| DevhostController::UnownedResultOf::CreateDevice_Impl::CreateDevice_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) { |
| if (_request_buffer.capacity() < CreateDeviceRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| CreateDeviceRequest _request = {}; |
| _request.coordinator_rpc = std::move(coordinator_rpc); |
| _request.device_controller_rpc = std::move(device_controller_rpc); |
| _request.driver_path = std::move(driver_path); |
| _request.driver = std::move(driver); |
| _request.parent_proxy = std::move(parent_proxy); |
| _request.proxy_args = std::move(proxy_args); |
| _request.local_device_id = std::move(local_device_id); |
| 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<CreateDeviceRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::operator=( |
| DevhostController::InPlace::CreateDevice(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| DevhostController::UnownedResultOf::CreateDevice DevhostController::SyncClient::CreateDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) { |
| return UnownedResultOf::CreateDevice(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id)); |
| } |
| |
| DevhostController::UnownedResultOf::CreateDevice DevhostController::Call::CreateDevice(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) { |
| return UnownedResultOf::CreateDevice(std::move(_client_end), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id)); |
| } |
| |
| ::fidl::internal::StatusAndError DevhostController::InPlace::CreateDevice(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceRequest> params) { |
| DevhostController::SetTransactionHeaderFor::CreateDeviceRequest(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); |
| } |
| } |
| |
| template <> |
| DevhostController::ResultOf::CreateCompositeDevice_Impl<DevhostController::CreateCompositeDeviceResponse>::CreateCompositeDevice_Impl(zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateCompositeDeviceRequest, ::fidl::MessageDirection::kSending>(); |
| ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined; |
| auto& _write_bytes_array = _write_bytes_inlined; |
| CreateCompositeDeviceRequest _request = {}; |
| _request.coordinator_rpc = std::move(coordinator_rpc); |
| _request.device_controller_rpc = std::move(device_controller_rpc); |
| _request.components = std::move(components); |
| _request.name = std::move(name); |
| _request.local_device_id = std::move(local_device_id); |
| 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<CreateCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| DevhostController::InPlace::CreateCompositeDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DevhostController::ResultOf::CreateCompositeDevice DevhostController::SyncClient::CreateCompositeDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) { |
| return ResultOf::CreateCompositeDevice(zx::unowned_channel(this->channel_), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id)); |
| } |
| |
| DevhostController::ResultOf::CreateCompositeDevice DevhostController::Call::CreateCompositeDevice(zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) { |
| return ResultOf::CreateCompositeDevice(std::move(_client_end), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id)); |
| } |
| |
| template <> |
| DevhostController::UnownedResultOf::CreateCompositeDevice_Impl<DevhostController::CreateCompositeDeviceResponse>::CreateCompositeDevice_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < CreateCompositeDeviceRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<CreateCompositeDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| CreateCompositeDeviceRequest _request = {}; |
| _request.coordinator_rpc = std::move(coordinator_rpc); |
| _request.device_controller_rpc = std::move(device_controller_rpc); |
| _request.components = std::move(components); |
| _request.name = std::move(name); |
| _request.local_device_id = std::move(local_device_id); |
| 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<CreateCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| DevhostController::InPlace::CreateCompositeDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DevhostController::UnownedResultOf::CreateCompositeDevice DevhostController::SyncClient::CreateCompositeDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::CreateCompositeDevice(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id), std::move(_response_buffer)); |
| } |
| |
| DevhostController::UnownedResultOf::CreateCompositeDevice DevhostController::Call::CreateCompositeDevice(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::CreateCompositeDevice(std::move(_client_end), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse> DevhostController::InPlace::CreateCompositeDevice(zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateCompositeDeviceRequest> params, ::fidl::BytePart response_buffer) { |
| DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<CreateCompositeDeviceRequest, CreateCompositeDeviceResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| bool DevhostController::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 kDevhostController_CreateDeviceStub_Ordinal: |
| case kDevhostController_CreateDeviceStub_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<CreateDeviceStubRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->CreateDeviceStub(std::move(message->coordinator_rpc), std::move(message->device_controller_rpc), std::move(message->protocol_id), std::move(message->local_device_id), |
| Interface::CreateDeviceStubCompleter::Sync(txn)); |
| return true; |
| } |
| case kDevhostController_CreateDevice_Ordinal: |
| case kDevhostController_CreateDevice_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<CreateDeviceRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->CreateDevice(std::move(message->coordinator_rpc), std::move(message->device_controller_rpc), std::move(message->driver_path), std::move(message->driver), std::move(message->parent_proxy), std::move(message->proxy_args), std::move(message->local_device_id), |
| Interface::CreateDeviceCompleter::Sync(txn)); |
| return true; |
| } |
| case kDevhostController_CreateCompositeDevice_Ordinal: |
| case kDevhostController_CreateCompositeDevice_GenOrdinal: |
| { |
| auto result = ::fidl::DecodeAs<CreateCompositeDeviceRequest>(msg); |
| if (result.status != ZX_OK) { |
| txn->Close(ZX_ERR_INVALID_ARGS); |
| return true; |
| } |
| auto message = result.message.message(); |
| impl->CreateCompositeDevice(std::move(message->coordinator_rpc), std::move(message->device_controller_rpc), std::move(message->components), std::move(message->name), std::move(message->local_device_id), |
| Interface::CreateCompositeDeviceCompleter::Sync(txn)); |
| return true; |
| } |
| default: { |
| return false; |
| } |
| } |
| } |
| |
| bool DevhostController::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 DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(int32_t status) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateCompositeDeviceResponse, ::fidl::MessageDirection::kSending>(); |
| FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {}; |
| auto& _response = *reinterpret_cast<CreateCompositeDeviceResponse*>(_write_bytes); |
| DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse( |
| ::fidl::DecodedMessage<CreateCompositeDeviceResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| CreateCompositeDeviceResponse::PrimarySize, |
| CreateCompositeDeviceResponse::PrimarySize))); |
| _response.status = std::move(status); |
| ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateCompositeDeviceResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<CreateCompositeDeviceResponse>(std::move(_response_bytes))); |
| } |
| |
| void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) { |
| if (_buffer.capacity() < CreateCompositeDeviceResponse::PrimarySize) { |
| CompleterBase::Close(ZX_ERR_INTERNAL); |
| return; |
| } |
| auto& _response = *reinterpret_cast<CreateCompositeDeviceResponse*>(_buffer.data()); |
| DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse( |
| ::fidl::DecodedMessage<CreateCompositeDeviceResponse>( |
| ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response), |
| CreateCompositeDeviceResponse::PrimarySize, |
| CreateCompositeDeviceResponse::PrimarySize))); |
| _response.status = std::move(status); |
| _buffer.set_actual(sizeof(CreateCompositeDeviceResponse)); |
| CompleterBase::SendReply(::fidl::DecodedMessage<CreateCompositeDeviceResponse>(std::move(_buffer))); |
| } |
| |
| void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(::fidl::DecodedMessage<CreateCompositeDeviceResponse> params) { |
| DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse(params); |
| CompleterBase::SendReply(std::move(params)); |
| } |
| |
| |
| |
| void DevhostController::SetTransactionHeaderFor::CreateDeviceStubRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceStubRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateDeviceStub_GenOrdinal); |
| } |
| |
| void DevhostController::SetTransactionHeaderFor::CreateDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateDevice_GenOrdinal); |
| } |
| |
| void DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceRequest>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateCompositeDevice_GenOrdinal); |
| } |
| void DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceResponse>& _msg) { |
| fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateCompositeDevice_GenOrdinal); |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::Coordinator_AddDevice_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::~Coordinator_AddDevice_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_AddDevice_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::MoveImpl_(Coordinator_AddDevice_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result, response_) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result, err_) == 8); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::Coordinator_AddDeviceInvisible_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::~Coordinator_AddDeviceInvisible_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_AddDeviceInvisible_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::MoveImpl_(Coordinator_AddDeviceInvisible_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result, response_) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result, err_) == 8); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::DeviceController_Unbind_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::~DeviceController_Unbind_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~DeviceController_Unbind_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::MoveImpl_(DeviceController_Unbind_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result) == ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response& ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::DeviceController_CompleteRemoval_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::~DeviceController_CompleteRemoval_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~DeviceController_CompleteRemoval_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::MoveImpl_(DeviceController_CompleteRemoval_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result) == ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response& ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::Coordinator_RunCompatibilityTests_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::~Coordinator_RunCompatibilityTests_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_RunCompatibilityTests_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::MoveImpl_(Coordinator_RunCompatibilityTests_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result) == ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response& ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::Coordinator_PublishMetadata_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::~Coordinator_PublishMetadata_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_PublishMetadata_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::MoveImpl_(Coordinator_PublishMetadata_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result) == ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response& ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::Coordinator_MakeVisible_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::~Coordinator_MakeVisible_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_MakeVisible_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::MoveImpl_(Coordinator_MakeVisible_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result) == ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response& ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::Coordinator_LoadFirmware_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::~Coordinator_LoadFirmware_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_LoadFirmware_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::MoveImpl_(Coordinator_LoadFirmware_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result, response_) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result, err_) == 8); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result) == ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response& ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::Coordinator_GetTopologicalPath_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::~Coordinator_GetTopologicalPath_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_GetTopologicalPath_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::MoveImpl_(Coordinator_GetTopologicalPath_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result, response_) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result, err_) == 8); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result) == ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response& ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::Coordinator_GetMetadata_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::~Coordinator_GetMetadata_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_GetMetadata_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::MoveImpl_(Coordinator_GetMetadata_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result, response_) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result, err_) == 8); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result) == ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::Coordinator_GetMetadataSize_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::~Coordinator_GetMetadataSize_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_GetMetadataSize_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::MoveImpl_(Coordinator_GetMetadataSize_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result, response_) == 8); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result, err_) == 8); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result) == ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::Coordinator_DirectoryWatch_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::~Coordinator_DirectoryWatch_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_DirectoryWatch_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::MoveImpl_(Coordinator_DirectoryWatch_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result) == ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response& ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::Coordinator_BindDevice_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::~Coordinator_BindDevice_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_BindDevice_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::MoveImpl_(Coordinator_BindDevice_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result) == ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response& ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::Coordinator_AddMetadata_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::~Coordinator_AddMetadata_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_AddMetadata_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::MoveImpl_(Coordinator_AddMetadata_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::Coordinator_AddCompositeDevice_Result() { |
| tag_ = Tag::Invalid; |
| } |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::~Coordinator_AddCompositeDevice_Result() { |
| Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::Destroy() { |
| switch (which()) { |
| case Tag::kResponse: |
| response_.~Coordinator_AddCompositeDevice_Response(); |
| break; |
| default: |
| break; |
| } |
| tag_ = Tag::Invalid; |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::MoveImpl_(Coordinator_AddCompositeDevice_Result&& other) { |
| switch (other.which()) { |
| case Tag::kResponse: |
| mutable_response() = std::move(other.mutable_response()); |
| break; |
| case Tag::kErr: |
| mutable_err() = std::move(other.mutable_err()); |
| break; |
| default: |
| break; |
| } |
| other.Destroy(); |
| } |
| |
| void ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::SizeAndOffsetAssertionHelper() { |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result, response_) == 4); |
| static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result, err_) == 4); |
| static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result) == ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::PrimarySize); |
| } |
| |
| |
| ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response& ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::mutable_response() { |
| if (which() != Tag::kResponse) { |
| Destroy(); |
| new (&response_) ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response; |
| } |
| tag_ = Tag::kResponse; |
| return response_; |
| } |
| |
| int32_t& ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::mutable_err() { |
| if (which() != Tag::kErr) { |
| Destroy(); |
| new (&err_) int32_t; |
| } |
| tag_ = Tag::kErr; |
| return err_; |
| } |
| |
| |
| namespace { |
| |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_BindDriver_Ordinal = 0x3d3eea9b00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_BindDriver_GenOrdinal = 0x1600a1d1d6024855lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerBindDriverRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerBindDriverResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerBindDriverResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_ConnectProxy_Ordinal = 0x582e0d9b00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_ConnectProxy_GenOrdinal = 0x72206da90d1f3f2flu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerConnectProxyRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerConnectProxyResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerConnectProxyResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_Unbind_Ordinal = 0x72bdd28200000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_Unbind_GenOrdinal = 0x2d3f793e42cc3fd0lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerUnbindRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerUnbindResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerUnbindResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_CompleteRemoval_Ordinal = 0x1554eba800000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_CompleteRemoval_GenOrdinal = 0x25d6d94c85d60771lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerCompleteRemovalRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerCompleteRemovalResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteRemovalResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_Suspend_Ordinal = 0x4490901a00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_Suspend_GenOrdinal = 0x77bf98a1d5d4adbblu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerSuspendRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerSuspendResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerSuspendResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_Resume_Ordinal = 0x4d69ba3300000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_Resume_GenOrdinal = 0x4f111286b7bd9caflu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerResumeRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerResumeResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerResumeResponseTable; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_CompleteCompatibilityTests_Ordinal = 0x475e367c00000000lu; |
| [[maybe_unused]] |
| constexpr uint64_t kDeviceController_CompleteCompatibilityTests_GenOrdinal = 0x3883342451945549lu; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable; |
| extern "C" const fidl_type_t fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsResponseTable; |
| extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsResponseTable; |
| |
| } // namespace |
| template <> |
| DeviceController::ResultOf::BindDriver_Impl<DeviceController::BindDriverResponse>::BindDriver_Impl(zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDriverRequest, ::fidl::MessageDirection::kSending>(); |
| std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>(); |
| auto& _write_bytes_array = *_write_bytes_boxed; |
| BindDriverRequest _request = {}; |
| _request.driver_path = std::move(driver_path); |
| _request.driver = std::move(driver); |
| 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<BindDriverRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| DeviceController::InPlace::BindDriver(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DeviceController::ResultOf::BindDriver DeviceController::SyncClient::BindDriver(::fidl::StringView driver_path, ::zx::vmo driver) { |
| return ResultOf::BindDriver(zx::unowned_channel(this->channel_), std::move(driver_path), std::move(driver)); |
| } |
| |
| DeviceController::ResultOf::BindDriver DeviceController::Call::BindDriver(zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver) { |
| return ResultOf::BindDriver(std::move(_client_end), std::move(driver_path), std::move(driver)); |
| } |
| |
| template <> |
| DeviceController::UnownedResultOf::BindDriver_Impl<DeviceController::BindDriverResponse>::BindDriver_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < BindDriverRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<BindDriverResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| BindDriverRequest _request = {}; |
| _request.driver_path = std::move(driver_path); |
| _request.driver = std::move(driver); |
| 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<BindDriverRequest> _decoded_request = std::move(_linearize_result.message); |
| Super::SetResult( |
| DeviceController::InPlace::BindDriver(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DeviceController::UnownedResultOf::BindDriver DeviceController::SyncClient::BindDriver(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::BindDriver(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(driver_path), std::move(driver), std::move(_response_buffer)); |
| } |
| |
| DeviceController::UnownedResultOf::BindDriver DeviceController::Call::BindDriver(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::BindDriver(std::move(_client_end), std::move(_request_buffer), std::move(driver_path), std::move(driver), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DeviceController::BindDriverResponse> DeviceController::InPlace::BindDriver(zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDriverRequest> params, ::fidl::BytePart response_buffer) { |
| DeviceController::SetTransactionHeaderFor::BindDriverRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::BindDriverResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<BindDriverRequest, BindDriverResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::BindDriverResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| |
| DeviceController::ResultOf::ConnectProxy_Impl::ConnectProxy_Impl(zx::unowned_channel _client_end, ::zx::channel shadow) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectProxyRequest, ::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, ConnectProxyRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<ConnectProxyRequest*>(_write_bytes); |
| _request.shadow = std::move(shadow); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectProxyRequest)); |
| ::fidl::DecodedMessage<ConnectProxyRequest> _decoded_request(std::move(_request_bytes)); |
| Super::operator=( |
| DeviceController::InPlace::ConnectProxy(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| DeviceController::ResultOf::ConnectProxy DeviceController::SyncClient::ConnectProxy(::zx::channel shadow) { |
| return ResultOf::ConnectProxy(zx::unowned_channel(this->channel_), std::move(shadow)); |
| } |
| |
| DeviceController::ResultOf::ConnectProxy DeviceController::Call::ConnectProxy(zx::unowned_channel _client_end, ::zx::channel shadow) { |
| return ResultOf::ConnectProxy(std::move(_client_end), std::move(shadow)); |
| } |
| |
| |
| DeviceController::UnownedResultOf::ConnectProxy_Impl::ConnectProxy_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow) { |
| if (_request_buffer.capacity() < ConnectProxyRequest::PrimarySize) { |
| Super::status_ = ZX_ERR_BUFFER_TOO_SMALL; |
| Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall; |
| return; |
| } |
| memset(_request_buffer.data(), 0, ConnectProxyRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<ConnectProxyRequest*>(_request_buffer.data()); |
| _request.shadow = std::move(shadow); |
| _request_buffer.set_actual(sizeof(ConnectProxyRequest)); |
| ::fidl::DecodedMessage<ConnectProxyRequest> _decoded_request(std::move(_request_buffer)); |
| Super::operator=( |
| DeviceController::InPlace::ConnectProxy(std::move(_client_end), std::move(_decoded_request))); |
| } |
| |
| DeviceController::UnownedResultOf::ConnectProxy DeviceController::SyncClient::ConnectProxy(::fidl::BytePart _request_buffer, ::zx::channel shadow) { |
| return UnownedResultOf::ConnectProxy(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(shadow)); |
| } |
| |
| DeviceController::UnownedResultOf::ConnectProxy DeviceController::Call::ConnectProxy(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow) { |
| return UnownedResultOf::ConnectProxy(std::move(_client_end), std::move(_request_buffer), std::move(shadow)); |
| } |
| |
| ::fidl::internal::StatusAndError DeviceController::InPlace::ConnectProxy(zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectProxyRequest> params) { |
| DeviceController::SetTransactionHeaderFor::ConnectProxyRequest(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); |
| } |
| } |
| |
| template <> |
| DeviceController::ResultOf::Unbind_Impl<DeviceController::UnbindResponse>::Unbind_Impl(zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindRequest, ::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, UnbindRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindRequest)); |
| ::fidl::DecodedMessage<UnbindRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DeviceController::InPlace::Unbind(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| DeviceController::ResultOf::Unbind DeviceController::SyncClient::Unbind() { |
| return ResultOf::Unbind(zx::unowned_channel(this->channel_)); |
| } |
| |
| DeviceController::ResultOf::Unbind DeviceController::Call::Unbind(zx::unowned_channel _client_end) { |
| return ResultOf::Unbind(std::move(_client_end)); |
| } |
| |
| template <> |
| DeviceController::UnownedResultOf::Unbind_Impl<DeviceController::UnbindResponse>::Unbind_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnbindRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, UnbindRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(UnbindRequest)); |
| ::fidl::DecodedMessage<UnbindRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| DeviceController::InPlace::Unbind(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| DeviceController::UnownedResultOf::Unbind DeviceController::SyncClient::Unbind(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Unbind(zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| DeviceController::UnownedResultOf::Unbind DeviceController::Call::Unbind(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Unbind(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DeviceController::UnbindResponse> DeviceController::InPlace::Unbind(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(UnbindRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<UnbindRequest> params(std::move(_request_buffer)); |
| DeviceController::SetTransactionHeaderFor::UnbindRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::UnbindResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<UnbindRequest, UnbindResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::UnbindResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| DeviceController::ResultOf::CompleteRemoval_Impl<DeviceController::CompleteRemovalResponse>::CompleteRemoval_Impl(zx::unowned_channel _client_end) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteRemovalRequest, ::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, CompleteRemovalRequest::PrimarySize); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CompleteRemovalRequest)); |
| ::fidl::DecodedMessage<CompleteRemovalRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DeviceController::InPlace::CompleteRemoval(std::move(_client_end), Super::response_buffer())); |
| } |
| |
| DeviceController::ResultOf::CompleteRemoval DeviceController::SyncClient::CompleteRemoval() { |
| return ResultOf::CompleteRemoval(zx::unowned_channel(this->channel_)); |
| } |
| |
| DeviceController::ResultOf::CompleteRemoval DeviceController::Call::CompleteRemoval(zx::unowned_channel _client_end) { |
| return ResultOf::CompleteRemoval(std::move(_client_end)); |
| } |
| |
| template <> |
| DeviceController::UnownedResultOf::CompleteRemoval_Impl<DeviceController::CompleteRemovalResponse>::CompleteRemoval_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CompleteRemovalRequest)] = {}; |
| ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes)); |
| memset(_request_buffer.data(), 0, CompleteRemovalRequest::PrimarySize); |
| _request_buffer.set_actual(sizeof(CompleteRemovalRequest)); |
| ::fidl::DecodedMessage<CompleteRemovalRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| DeviceController::InPlace::CompleteRemoval(std::move(_client_end), std::move(_response_buffer))); |
| } |
| |
| DeviceController::UnownedResultOf::CompleteRemoval DeviceController::SyncClient::CompleteRemoval(::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::CompleteRemoval(zx::unowned_channel(this->channel_), std::move(_response_buffer)); |
| } |
| |
| DeviceController::UnownedResultOf::CompleteRemoval DeviceController::Call::CompleteRemoval(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::CompleteRemoval(std::move(_client_end), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DeviceController::CompleteRemovalResponse> DeviceController::InPlace::CompleteRemoval(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) { |
| constexpr uint32_t _write_num_bytes = sizeof(CompleteRemovalRequest); |
| ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes; |
| ::fidl::BytePart _request_buffer = _write_bytes.view(); |
| _request_buffer.set_actual(_write_num_bytes); |
| ::fidl::DecodedMessage<CompleteRemovalRequest> params(std::move(_request_buffer)); |
| DeviceController::SetTransactionHeaderFor::CompleteRemovalRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::CompleteRemovalResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<CompleteRemovalRequest, CompleteRemovalResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::CompleteRemovalResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| DeviceController::ResultOf::Suspend_Impl<DeviceController::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, uint32_t flags) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::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, SuspendRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes); |
| _request.flags = std::move(flags); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest)); |
| ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DeviceController::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DeviceController::ResultOf::Suspend DeviceController::SyncClient::Suspend(uint32_t flags) { |
| return ResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(flags)); |
| } |
| |
| DeviceController::ResultOf::Suspend DeviceController::Call::Suspend(zx::unowned_channel _client_end, uint32_t flags) { |
| return ResultOf::Suspend(std::move(_client_end), std::move(flags)); |
| } |
| |
| template <> |
| DeviceController::UnownedResultOf::Suspend_Impl<DeviceController::SuspendResponse>::Suspend_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) { |
| if (_request_buffer.capacity() < SuspendRequest::PrimarySize) { |
| Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall)); |
| return; |
| } |
| memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data()); |
| _request.flags = std::move(flags); |
| _request_buffer.set_actual(sizeof(SuspendRequest)); |
| ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer)); |
| Super::SetResult( |
| DeviceController::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer))); |
| } |
| |
| DeviceController::UnownedResultOf::Suspend DeviceController::SyncClient::Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Suspend(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer)); |
| } |
| |
| DeviceController::UnownedResultOf::Suspend DeviceController::Call::Suspend(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) { |
| return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer)); |
| } |
| |
| ::fidl::DecodeResult<DeviceController::SuspendResponse> DeviceController::InPlace::Suspend(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) { |
| DeviceController::SetTransactionHeaderFor::SuspendRequest(params); |
| auto _encode_request_result = ::fidl::Encode(std::move(params)); |
| if (_encode_request_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::SuspendResponse>::FromFailure( |
| std::move(_encode_request_result)); |
| } |
| auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>( |
| std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer)); |
| if (_call_result.status != ZX_OK) { |
| return ::fidl::DecodeResult<DeviceController::SuspendResponse>::FromFailure( |
| std::move(_call_result)); |
| } |
| return ::fidl::Decode(std::move(_call_result.message)); |
| } |
| |
| template <> |
| DeviceController::ResultOf::Resume_Impl<DeviceController::ResumeResponse>::Resume_Impl(zx::unowned_channel _client_end, uint32_t target_system_state) { |
| constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeRequest, ::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, ResumeRequest::PrimarySize); |
| auto& _request = *reinterpret_cast<ResumeRequest*>(_write_bytes); |
| _request.target_system_state = std::move(target_system_state); |
| ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeRequest)); |
| ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_bytes)); |
| Super::SetResult( |
| DeviceController::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), Super::response_buffer())); |
| } |
| |
| DeviceController::ResultOf::Resume DeviceController::SyncClient::Resume(uint32_t target_system_state) { |
| return ResultOf::Resume(zx::unowned_channel(this->channel_), std::move(target_system_state)); |
| } |
| |
| DeviceController::ResultOf::Resume DeviceController::Call::Resume(zx::unowned_channel _client_end, uint32_t target_system_state) { |
| return ResultOf::Resume(std::move(_client_end), std::move(target_system_state)); |
| } |
| |
| template <> |
| DeviceController::UnownedResultOf::Resume_Impl<DeviceController::ResumeResponse>::Resume_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer) { |