blob: 0cbdf7a600f09ad2d616a956dabd4270c069f211 [file] [log] [blame]
// 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) {