zircon/system/fidl/fuchsia-kernel/gen/llcpp/fidl.cc

// WARNING: This file is machine generated by fidlgen.

#include <fuchsia/kernel/llcpp/fidl.h>
#include <memory>

namespace llcpp {

namespace fuchsia {
namespace kernel {

::llcpp::fuchsia::kernel::PerCpuStats::Builder PerCpuStats::Build() {
  return PerCpuStats::Builder();
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_cpu_number(uint32_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[1 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 1) {
    max_ordinal_ = 1;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_flags(uint32_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[2 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 2) {
    max_ordinal_ = 2;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_idle_time(int64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[3 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 3) {
    max_ordinal_ = 3;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_reschedules(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[4 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 4) {
    max_ordinal_ = 4;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_context_switches(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[5 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 5) {
    max_ordinal_ = 5;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_irq_preempts(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[6 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 6) {
    max_ordinal_ = 6;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_yields(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[7 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 7) {
    max_ordinal_ = 7;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_ints(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[8 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 8) {
    max_ordinal_ = 8;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_timer_ints(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[9 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 9) {
    max_ordinal_ = 9;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_timers(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[10 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 10) {
    max_ordinal_ = 10;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_page_faults(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[11 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 11) {
    max_ordinal_ = 11;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_exceptions(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[12 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 12) {
    max_ordinal_ = 12;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_syscalls(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[13 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 13) {
    max_ordinal_ = 13;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_reschedule_ipis(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[14 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 14) {
    max_ordinal_ = 14;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_generic_ipis(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[15 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 15) {
    max_ordinal_ = 15;
  }
  return std::move(*this);
}

namespace {

[[maybe_unused]]
constexpr uint64_t kMexecBroker_PerformMexec_Ordinal = 0x2db06f5f00000000lu;
[[maybe_unused]]
constexpr uint64_t kMexecBroker_PerformMexec_GenOrdinal = 0x191f56222830486flu;
extern "C" const fidl_type_t v1_fuchsia_kernel_MexecBrokerPerformMexecRequestTable;
extern "C" const fidl_type_t v1_fuchsia_kernel_MexecBrokerPerformMexecResponseTable;

}  // namespace

MexecBroker::ResultOf::PerformMexec_Impl::PerformMexec_Impl(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PerformMexecRequest, ::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, PerformMexecRequest::PrimarySize);
  auto& _request = *reinterpret_cast<PerformMexecRequest*>(_write_bytes);
  _request.kernel = std::move(kernel);
  _request.bootdata = std::move(bootdata);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(PerformMexecRequest));
  ::fidl::DecodedMessage<PerformMexecRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      MexecBroker::InPlace::PerformMexec(std::move(_client_end), std::move(_decoded_request)));
}

MexecBroker::ResultOf::PerformMexec MexecBroker::SyncClient::PerformMexec(::zx::vmo kernel, ::zx::vmo bootdata) {
    return ResultOf::PerformMexec(::zx::unowned_channel(this->channel_), std::move(kernel), std::move(bootdata));
}

MexecBroker::ResultOf::PerformMexec MexecBroker::Call::PerformMexec(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata) {
  return ResultOf::PerformMexec(std::move(_client_end), std::move(kernel), std::move(bootdata));
}


MexecBroker::UnownedResultOf::PerformMexec_Impl::PerformMexec_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) {
  if (_request_buffer.capacity() < PerformMexecRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, PerformMexecRequest::PrimarySize);
  auto& _request = *reinterpret_cast<PerformMexecRequest*>(_request_buffer.data());
  _request.kernel = std::move(kernel);
  _request.bootdata = std::move(bootdata);
  _request_buffer.set_actual(sizeof(PerformMexecRequest));
  ::fidl::DecodedMessage<PerformMexecRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      MexecBroker::InPlace::PerformMexec(std::move(_client_end), std::move(_decoded_request)));
}

MexecBroker::UnownedResultOf::PerformMexec MexecBroker::SyncClient::PerformMexec(::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) {
  return UnownedResultOf::PerformMexec(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(kernel), std::move(bootdata));
}

MexecBroker::UnownedResultOf::PerformMexec MexecBroker::Call::PerformMexec(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) {
  return UnownedResultOf::PerformMexec(std::move(_client_end), std::move(_request_buffer), std::move(kernel), std::move(bootdata));
}

::fidl::internal::StatusAndError MexecBroker::InPlace::PerformMexec(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PerformMexecRequest> params) {
  MexecBroker::SetTransactionHeaderFor::PerformMexecRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::internal::StatusAndError::FromFailure(
        std::move(_encode_request_result));
  }
  zx_status_t _write_status =
      ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
  if (_write_status != ZX_OK) {
    return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
  } else {
    return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
  }
}


bool MexecBroker::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 kMexecBroker_PerformMexec_Ordinal:
    case kMexecBroker_PerformMexec_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<PerformMexecRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->PerformMexec(std::move(message->kernel), std::move(message->bootdata),
          Interface::PerformMexecCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool MexecBroker::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 MexecBroker::SetTransactionHeaderFor::PerformMexecRequest(const ::fidl::DecodedMessage<MexecBroker::PerformMexecRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kMexecBroker_PerformMexec_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kDebugBroker_SendDebugCommand_Ordinal = 0x3f05f48400000000lu;
[[maybe_unused]]
constexpr uint64_t kDebugBroker_SendDebugCommand_GenOrdinal = 0x1ee270f83b5d6ff6lu;
extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSendDebugCommandRequestTable;
extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSendDebugCommandResponseTable;
[[maybe_unused]]
constexpr uint64_t kDebugBroker_SetTracingEnabled_Ordinal = 0x273cf2d900000000lu;
[[maybe_unused]]
constexpr uint64_t kDebugBroker_SetTracingEnabled_GenOrdinal = 0x12e368d05329b30elu;
extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSetTracingEnabledRequestTable;
extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSetTracingEnabledResponseTable;

}  // namespace
template <>
DebugBroker::ResultOf::SendDebugCommand_Impl<DebugBroker::SendDebugCommandResponse>::SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::StringView command) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendDebugCommandRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  SendDebugCommandRequest _request = {};
  _request.command = std::move(command);
  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<SendDebugCommandRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      DebugBroker::InPlace::SendDebugCommand(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DebugBroker::ResultOf::SendDebugCommand DebugBroker::SyncClient::SendDebugCommand(::fidl::StringView command) {
    return ResultOf::SendDebugCommand(::zx::unowned_channel(this->channel_), std::move(command));
}

DebugBroker::ResultOf::SendDebugCommand DebugBroker::Call::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::StringView command) {
  return ResultOf::SendDebugCommand(std::move(_client_end), std::move(command));
}

template <>
DebugBroker::UnownedResultOf::SendDebugCommand_Impl<DebugBroker::SendDebugCommandResponse>::SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SendDebugCommandRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SendDebugCommandResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  SendDebugCommandRequest _request = {};
  _request.command = std::move(command);
  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<SendDebugCommandRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      DebugBroker::InPlace::SendDebugCommand(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DebugBroker::UnownedResultOf::SendDebugCommand DebugBroker::SyncClient::SendDebugCommand(::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SendDebugCommand(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(command), std::move(_response_buffer));
}

DebugBroker::UnownedResultOf::SendDebugCommand DebugBroker::Call::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SendDebugCommand(std::move(_client_end), std::move(_request_buffer), std::move(command), std::move(_response_buffer));
}

::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse> DebugBroker::InPlace::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SendDebugCommandRequest> params, ::fidl::BytePart response_buffer) {
  DebugBroker::SetTransactionHeaderFor::SendDebugCommandRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<SendDebugCommandRequest, SendDebugCommandResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
DebugBroker::ResultOf::SetTracingEnabled_Impl<DebugBroker::SetTracingEnabledResponse>::SetTracingEnabled_Impl(::zx::unowned_channel _client_end, bool enabled) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTracingEnabledRequest, ::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, SetTracingEnabledRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetTracingEnabledRequest*>(_write_bytes);
  _request.enabled = std::move(enabled);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTracingEnabledRequest));
  ::fidl::DecodedMessage<SetTracingEnabledRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      DebugBroker::InPlace::SetTracingEnabled(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

DebugBroker::ResultOf::SetTracingEnabled DebugBroker::SyncClient::SetTracingEnabled(bool enabled) {
    return ResultOf::SetTracingEnabled(::zx::unowned_channel(this->channel_), std::move(enabled));
}

DebugBroker::ResultOf::SetTracingEnabled DebugBroker::Call::SetTracingEnabled(::zx::unowned_channel _client_end, bool enabled) {
  return ResultOf::SetTracingEnabled(std::move(_client_end), std::move(enabled));
}

template <>
DebugBroker::UnownedResultOf::SetTracingEnabled_Impl<DebugBroker::SetTracingEnabledResponse>::SetTracingEnabled_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < SetTracingEnabledRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<SetTracingEnabledResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, SetTracingEnabledRequest::PrimarySize);
  auto& _request = *reinterpret_cast<SetTracingEnabledRequest*>(_request_buffer.data());
  _request.enabled = std::move(enabled);
  _request_buffer.set_actual(sizeof(SetTracingEnabledRequest));
  ::fidl::DecodedMessage<SetTracingEnabledRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      DebugBroker::InPlace::SetTracingEnabled(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

DebugBroker::UnownedResultOf::SetTracingEnabled DebugBroker::SyncClient::SetTracingEnabled(::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetTracingEnabled(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
}

DebugBroker::UnownedResultOf::SetTracingEnabled DebugBroker::Call::SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::SetTracingEnabled(std::move(_client_end), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
}

::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse> DebugBroker::InPlace::SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTracingEnabledRequest> params, ::fidl::BytePart response_buffer) {
  DebugBroker::SetTransactionHeaderFor::SetTracingEnabledRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<SetTracingEnabledRequest, SetTracingEnabledResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool DebugBroker::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 kDebugBroker_SendDebugCommand_Ordinal:
    case kDebugBroker_SendDebugCommand_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SendDebugCommandRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SendDebugCommand(std::move(message->command),
          Interface::SendDebugCommandCompleter::Sync(txn));
      return true;
    }
    case kDebugBroker_SetTracingEnabled_Ordinal:
    case kDebugBroker_SetTracingEnabled_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<SetTracingEnabledRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->SetTracingEnabled(std::move(message->enabled),
          Interface::SetTracingEnabledCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool DebugBroker::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 DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendDebugCommandResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<SendDebugCommandResponse*>(_write_bytes);
  DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(
      ::fidl::DecodedMessage<SendDebugCommandResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SendDebugCommandResponse::PrimarySize,
              SendDebugCommandResponse::PrimarySize)));
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SendDebugCommandResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SendDebugCommandResponse>(std::move(_response_bytes)));
}

void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < SendDebugCommandResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<SendDebugCommandResponse*>(_buffer.data());
  DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(
      ::fidl::DecodedMessage<SendDebugCommandResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SendDebugCommandResponse::PrimarySize,
              SendDebugCommandResponse::PrimarySize)));
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(SendDebugCommandResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SendDebugCommandResponse>(std::move(_buffer)));
}

void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(::fidl::DecodedMessage<SendDebugCommandResponse> params) {
  DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTracingEnabledResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<SetTracingEnabledResponse*>(_write_bytes);
  DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(
      ::fidl::DecodedMessage<SetTracingEnabledResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetTracingEnabledResponse::PrimarySize,
              SetTracingEnabledResponse::PrimarySize)));
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTracingEnabledResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SetTracingEnabledResponse>(std::move(_response_bytes)));
}

void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < SetTracingEnabledResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<SetTracingEnabledResponse*>(_buffer.data());
  DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(
      ::fidl::DecodedMessage<SetTracingEnabledResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              SetTracingEnabledResponse::PrimarySize,
              SetTracingEnabledResponse::PrimarySize)));
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(SetTracingEnabledResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<SetTracingEnabledResponse>(std::move(_buffer)));
}

void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(::fidl::DecodedMessage<SetTracingEnabledResponse> params) {
  DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void DebugBroker::SetTransactionHeaderFor::SendDebugCommandRequest(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SendDebugCommand_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SendDebugCommand_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void DebugBroker::SetTransactionHeaderFor::SetTracingEnabledRequest(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SetTracingEnabled_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SetTracingEnabled_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kCounter_GetInspectVmo_Ordinal = 0x1ba5957d00000000lu;
[[maybe_unused]]
constexpr uint64_t kCounter_GetInspectVmo_GenOrdinal = 0x6ea9b2e6b2791b81lu;
extern "C" const fidl_type_t v1_fuchsia_kernel_CounterGetInspectVmoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_kernel_CounterGetInspectVmoResponseTable;
[[maybe_unused]]
constexpr uint64_t kCounter_UpdateInspectVmo_Ordinal = 0x4556672400000000lu;
[[maybe_unused]]
constexpr uint64_t kCounter_UpdateInspectVmo_GenOrdinal = 0x1d25eb7995a0539flu;
extern "C" const fidl_type_t v1_fuchsia_kernel_CounterUpdateInspectVmoRequestTable;
extern "C" const fidl_type_t v1_fuchsia_kernel_CounterUpdateInspectVmoResponseTable;

}  // namespace
template <>
Counter::ResultOf::GetInspectVmo_Impl<Counter::GetInspectVmoResponse>::GetInspectVmo_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInspectVmoRequest, ::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, GetInspectVmoRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInspectVmoRequest));
  ::fidl::DecodedMessage<GetInspectVmoRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Counter::InPlace::GetInspectVmo(std::move(_client_end), Super::response_buffer()));
}

Counter::ResultOf::GetInspectVmo Counter::SyncClient::GetInspectVmo() {
    return ResultOf::GetInspectVmo(::zx::unowned_channel(this->channel_));
}

Counter::ResultOf::GetInspectVmo Counter::Call::GetInspectVmo(::zx::unowned_channel _client_end) {
  return ResultOf::GetInspectVmo(std::move(_client_end));
}

template <>
Counter::UnownedResultOf::GetInspectVmo_Impl<Counter::GetInspectVmoResponse>::GetInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInspectVmoRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetInspectVmoRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetInspectVmoRequest));
  ::fidl::DecodedMessage<GetInspectVmoRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Counter::InPlace::GetInspectVmo(std::move(_client_end), std::move(_response_buffer)));
}

Counter::UnownedResultOf::GetInspectVmo Counter::SyncClient::GetInspectVmo(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetInspectVmo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Counter::UnownedResultOf::GetInspectVmo Counter::Call::GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetInspectVmo(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Counter::GetInspectVmoResponse> Counter::InPlace::GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetInspectVmoRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetInspectVmoRequest> params(std::move(_request_buffer));
  Counter::SetTransactionHeaderFor::GetInspectVmoRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Counter::GetInspectVmoResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetInspectVmoRequest, GetInspectVmoResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Counter::GetInspectVmoResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Counter::ResultOf::UpdateInspectVmo_Impl<Counter::UpdateInspectVmoResponse>::UpdateInspectVmo_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateInspectVmoRequest, ::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, UpdateInspectVmoRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UpdateInspectVmoRequest));
  ::fidl::DecodedMessage<UpdateInspectVmoRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Counter::InPlace::UpdateInspectVmo(std::move(_client_end), Super::response_buffer()));
}

Counter::ResultOf::UpdateInspectVmo Counter::SyncClient::UpdateInspectVmo() {
    return ResultOf::UpdateInspectVmo(::zx::unowned_channel(this->channel_));
}

Counter::ResultOf::UpdateInspectVmo Counter::Call::UpdateInspectVmo(::zx::unowned_channel _client_end) {
  return ResultOf::UpdateInspectVmo(std::move(_client_end));
}

template <>
Counter::UnownedResultOf::UpdateInspectVmo_Impl<Counter::UpdateInspectVmoResponse>::UpdateInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UpdateInspectVmoRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, UpdateInspectVmoRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(UpdateInspectVmoRequest));
  ::fidl::DecodedMessage<UpdateInspectVmoRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Counter::InPlace::UpdateInspectVmo(std::move(_client_end), std::move(_response_buffer)));
}

Counter::UnownedResultOf::UpdateInspectVmo Counter::SyncClient::UpdateInspectVmo(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::UpdateInspectVmo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Counter::UnownedResultOf::UpdateInspectVmo Counter::Call::UpdateInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::UpdateInspectVmo(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Counter::UpdateInspectVmoResponse> Counter::InPlace::UpdateInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(UpdateInspectVmoRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<UpdateInspectVmoRequest> params(std::move(_request_buffer));
  Counter::SetTransactionHeaderFor::UpdateInspectVmoRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Counter::UpdateInspectVmoResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<UpdateInspectVmoRequest, UpdateInspectVmoResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Counter::UpdateInspectVmoResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool Counter::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 kCounter_GetInspectVmo_Ordinal:
    case kCounter_GetInspectVmo_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetInspectVmoRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetInspectVmo(
          Interface::GetInspectVmoCompleter::Sync(txn));
      return true;
    }
    case kCounter_UpdateInspectVmo_Ordinal:
    case kCounter_UpdateInspectVmo_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<UpdateInspectVmoRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->UpdateInspectVmo(
          Interface::UpdateInspectVmoCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Counter::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 Counter::Interface::GetInspectVmoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::mem::Buffer buffer) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInspectVmoResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetInspectVmoResponse*>(_write_bytes);
  Counter::SetTransactionHeaderFor::GetInspectVmoResponse(
      ::fidl::DecodedMessage<GetInspectVmoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInspectVmoResponse::PrimarySize,
              GetInspectVmoResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.buffer = std::move(buffer);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInspectVmoResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetInspectVmoResponse>(std::move(_response_bytes)));
}

void Counter::Interface::GetInspectVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::mem::Buffer buffer) {
  if (_buffer.capacity() < GetInspectVmoResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetInspectVmoResponse*>(_buffer.data());
  Counter::SetTransactionHeaderFor::GetInspectVmoResponse(
      ::fidl::DecodedMessage<GetInspectVmoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetInspectVmoResponse::PrimarySize,
              GetInspectVmoResponse::PrimarySize)));
  _response.status = std::move(status);
  _response.buffer = std::move(buffer);
  _buffer.set_actual(sizeof(GetInspectVmoResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetInspectVmoResponse>(std::move(_buffer)));
}

void Counter::Interface::GetInspectVmoCompleterBase::Reply(::fidl::DecodedMessage<GetInspectVmoResponse> params) {
  Counter::SetTransactionHeaderFor::GetInspectVmoResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(int32_t status) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateInspectVmoResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<UpdateInspectVmoResponse*>(_write_bytes);
  Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(
      ::fidl::DecodedMessage<UpdateInspectVmoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              UpdateInspectVmoResponse::PrimarySize,
              UpdateInspectVmoResponse::PrimarySize)));
  _response.status = std::move(status);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UpdateInspectVmoResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<UpdateInspectVmoResponse>(std::move(_response_bytes)));
}

void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
  if (_buffer.capacity() < UpdateInspectVmoResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<UpdateInspectVmoResponse*>(_buffer.data());
  Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(
      ::fidl::DecodedMessage<UpdateInspectVmoResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              UpdateInspectVmoResponse::PrimarySize,
              UpdateInspectVmoResponse::PrimarySize)));
  _response.status = std::move(status);
  _buffer.set_actual(sizeof(UpdateInspectVmoResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<UpdateInspectVmoResponse>(std::move(_buffer)));
}

void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(::fidl::DecodedMessage<UpdateInspectVmoResponse> params) {
  Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void Counter::SetTransactionHeaderFor::GetInspectVmoRequest(const ::fidl::DecodedMessage<Counter::GetInspectVmoRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_GetInspectVmo_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Counter::SetTransactionHeaderFor::GetInspectVmoResponse(const ::fidl::DecodedMessage<Counter::GetInspectVmoResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_GetInspectVmo_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Counter::SetTransactionHeaderFor::UpdateInspectVmoRequest(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_UpdateInspectVmo_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_UpdateInspectVmo_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

::llcpp::fuchsia::kernel::MemoryStats::Builder MemoryStats::Build() {
  return MemoryStats::Builder();
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_total_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[1 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 1) {
    max_ordinal_ = 1;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_free_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[2 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 2) {
    max_ordinal_ = 2;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_wired_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[3 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 3) {
    max_ordinal_ = 3;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_total_heap_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[4 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 4) {
    max_ordinal_ = 4;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_free_heap_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[5 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 5) {
    max_ordinal_ = 5;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_vmo_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[6 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 6) {
    max_ordinal_ = 6;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_mmu_overhead_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[7 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 7) {
    max_ordinal_ = 7;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_ipc_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[8 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 8) {
    max_ordinal_ = 8;
  }
  return std::move(*this);
}

auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_other_bytes(uint64_t* elem) -> Builder&& {
  ZX_ASSERT(elem);
  envelopes_[9 - 1].data = static_cast<void*>(elem);
  if (max_ordinal_ < 9) {
    max_ordinal_ = 9;
  }
  return std::move(*this);
}

namespace {

[[maybe_unused]]
constexpr uint64_t kStats_GetMemoryStats_Ordinal = 0x3f74d35b00000000lu;
[[maybe_unused]]
constexpr uint64_t kStats_GetMemoryStats_GenOrdinal = 0x686677932ae41074lu;
extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetMemoryStatsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetMemoryStatsResponseTable;
[[maybe_unused]]
constexpr uint64_t kStats_GetCpuStats_Ordinal = 0x34c546a700000000lu;
[[maybe_unused]]
constexpr uint64_t kStats_GetCpuStats_GenOrdinal = 0x470e2684ca1ca19elu;
extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetCpuStatsRequestTable;
extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetCpuStatsResponseTable;

}  // namespace
template <>
Stats::ResultOf::GetMemoryStats_Impl<Stats::GetMemoryStatsResponse>::GetMemoryStats_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemoryStatsRequest, ::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, GetMemoryStatsRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMemoryStatsRequest));
  ::fidl::DecodedMessage<GetMemoryStatsRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Stats::InPlace::GetMemoryStats(std::move(_client_end), Super::response_buffer()));
}

Stats::ResultOf::GetMemoryStats Stats::SyncClient::GetMemoryStats() {
    return ResultOf::GetMemoryStats(::zx::unowned_channel(this->channel_));
}

Stats::ResultOf::GetMemoryStats Stats::Call::GetMemoryStats(::zx::unowned_channel _client_end) {
  return ResultOf::GetMemoryStats(std::move(_client_end));
}

template <>
Stats::UnownedResultOf::GetMemoryStats_Impl<Stats::GetMemoryStatsResponse>::GetMemoryStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetMemoryStatsRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetMemoryStatsRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetMemoryStatsRequest));
  ::fidl::DecodedMessage<GetMemoryStatsRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Stats::InPlace::GetMemoryStats(std::move(_client_end), std::move(_response_buffer)));
}

Stats::UnownedResultOf::GetMemoryStats Stats::SyncClient::GetMemoryStats(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetMemoryStats(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Stats::UnownedResultOf::GetMemoryStats Stats::Call::GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetMemoryStats(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Stats::GetMemoryStatsResponse> Stats::InPlace::GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetMemoryStatsRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetMemoryStatsRequest> params(std::move(_request_buffer));
  Stats::SetTransactionHeaderFor::GetMemoryStatsRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Stats::GetMemoryStatsResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetMemoryStatsRequest, GetMemoryStatsResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Stats::GetMemoryStatsResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}

template <>
Stats::ResultOf::GetCpuStats_Impl<Stats::GetCpuStatsResponse>::GetCpuStats_Impl(::zx::unowned_channel _client_end) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCpuStatsRequest, ::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, GetCpuStatsRequest::PrimarySize);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCpuStatsRequest));
  ::fidl::DecodedMessage<GetCpuStatsRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Stats::InPlace::GetCpuStats(std::move(_client_end), Super::response_buffer()));
}

Stats::ResultOf::GetCpuStats Stats::SyncClient::GetCpuStats() {
    return ResultOf::GetCpuStats(::zx::unowned_channel(this->channel_));
}

Stats::ResultOf::GetCpuStats Stats::Call::GetCpuStats(::zx::unowned_channel _client_end) {
  return ResultOf::GetCpuStats(std::move(_client_end));
}

template <>
Stats::UnownedResultOf::GetCpuStats_Impl<Stats::GetCpuStatsResponse>::GetCpuStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCpuStatsRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetCpuStatsRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetCpuStatsRequest));
  ::fidl::DecodedMessage<GetCpuStatsRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Stats::InPlace::GetCpuStats(std::move(_client_end), std::move(_response_buffer)));
}

Stats::UnownedResultOf::GetCpuStats Stats::SyncClient::GetCpuStats(::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetCpuStats(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
}

Stats::UnownedResultOf::GetCpuStats Stats::Call::GetCpuStats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::GetCpuStats(std::move(_client_end), std::move(_response_buffer));
}

::fidl::DecodeResult<Stats::GetCpuStatsResponse> Stats::InPlace::GetCpuStats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
  constexpr uint32_t _write_num_bytes = sizeof(GetCpuStatsRequest);
  ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
  ::fidl::BytePart _request_buffer = _write_bytes.view();
  _request_buffer.set_actual(_write_num_bytes);
  ::fidl::DecodedMessage<GetCpuStatsRequest> params(std::move(_request_buffer));
  Stats::SetTransactionHeaderFor::GetCpuStatsRequest(params);
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Stats::GetCpuStatsResponse>::FromFailure(
        std::move(_encode_request_result));
  }
  auto _call_result = ::fidl::Call<GetCpuStatsRequest, GetCpuStatsResponse>(
    std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<Stats::GetCpuStatsResponse>::FromFailure(
        std::move(_call_result));
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


bool Stats::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 kStats_GetMemoryStats_Ordinal:
    case kStats_GetMemoryStats_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetMemoryStatsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetMemoryStats(
          Interface::GetMemoryStatsCompleter::Sync(txn));
      return true;
    }
    case kStats_GetCpuStats_Ordinal:
    case kStats_GetCpuStats_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetCpuStatsRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetCpuStats(
          Interface::GetCpuStatsCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Stats::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 Stats::Interface::GetMemoryStatsCompleterBase::Reply(::llcpp::fuchsia::kernel::MemoryStats stats) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemoryStatsResponse, ::fidl::MessageDirection::kSending>();
  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
  GetMemoryStatsResponse _response = {};
  Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(
      ::fidl::DecodedMessage<GetMemoryStatsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetMemoryStatsResponse::PrimarySize,
              GetMemoryStatsResponse::PrimarySize)));
  _response.stats = std::move(stats);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}

void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::MemoryStats stats) {
  if (_buffer.capacity() < GetMemoryStatsResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetMemoryStatsResponse _response = {};
  Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(
      ::fidl::DecodedMessage<GetMemoryStatsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetMemoryStatsResponse::PrimarySize,
              GetMemoryStatsResponse::PrimarySize)));
  _response.stats = std::move(stats);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}

void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::fidl::DecodedMessage<GetMemoryStatsResponse> params) {
  Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Stats::Interface::GetCpuStatsCompleterBase::Reply(::llcpp::fuchsia::kernel::CpuStats stats) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCpuStatsResponse, ::fidl::MessageDirection::kSending>();
  std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
  uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
  GetCpuStatsResponse _response = {};
  Stats::SetTransactionHeaderFor::GetCpuStatsResponse(
      ::fidl::DecodedMessage<GetCpuStatsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetCpuStatsResponse::PrimarySize,
              GetCpuStatsResponse::PrimarySize)));
  _response.stats = std::move(stats);
  auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
                                                                          _kWriteAllocSize));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}

void Stats::Interface::GetCpuStatsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::CpuStats stats) {
  if (_buffer.capacity() < GetCpuStatsResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  GetCpuStatsResponse _response = {};
  Stats::SetTransactionHeaderFor::GetCpuStatsResponse(
      ::fidl::DecodedMessage<GetCpuStatsResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetCpuStatsResponse::PrimarySize,
              GetCpuStatsResponse::PrimarySize)));
  _response.stats = std::move(stats);
  auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
  if (_linearize_result.status != ZX_OK) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  CompleterBase::SendReply(std::move(_linearize_result.message));
}

void Stats::Interface::GetCpuStatsCompleterBase::Reply(::fidl::DecodedMessage<GetCpuStatsResponse> params) {
  Stats::SetTransactionHeaderFor::GetCpuStatsResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void Stats::SetTransactionHeaderFor::GetMemoryStatsRequest(const ::fidl::DecodedMessage<Stats::GetMemoryStatsRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetMemoryStats_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(const ::fidl::DecodedMessage<Stats::GetMemoryStatsResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetMemoryStats_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Stats::SetTransactionHeaderFor::GetCpuStatsRequest(const ::fidl::DecodedMessage<Stats::GetCpuStatsRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetCpuStats_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Stats::SetTransactionHeaderFor::GetCpuStatsResponse(const ::fidl::DecodedMessage<Stats::GetCpuStatsResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetCpuStats_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

}  // namespace kernel
}  // namespace fuchsia
}  // namespace llcpp