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

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

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

namespace llcpp {

namespace fuchsia {
namespace boot {

namespace {

[[maybe_unused]]
constexpr uint64_t kWriteOnlyLog_Get_Ordinal = 0x6bf285c200000000lu;
[[maybe_unused]]
constexpr uint64_t kWriteOnlyLog_Get_GenOrdinal = 0x4579dac289d3007lu;
extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetResponseTable;

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

WriteOnlyLog::ResultOf::Get WriteOnlyLog::SyncClient::Get() {
    return ResultOf::Get(::zx::unowned_channel(this->channel_));
}

WriteOnlyLog::ResultOf::Get WriteOnlyLog::Call::Get(::zx::unowned_channel _client_end) {
  return ResultOf::Get(std::move(_client_end));
}

template <>
WriteOnlyLog::UnownedResultOf::Get_Impl<WriteOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      WriteOnlyLog::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


bool WriteOnlyLog::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 kWriteOnlyLog_Get_Ordinal:
    case kWriteOnlyLog_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Get(
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void WriteOnlyLog::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::debuglog log) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  WriteOnlyLog::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.log = std::move(log);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void WriteOnlyLog::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  WriteOnlyLog::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void WriteOnlyLog::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<WriteOnlyLog::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kWriteOnlyLog_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void WriteOnlyLog::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<WriteOnlyLog::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kWriteOnlyLog_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kReadOnlyLog_Get_Ordinal = 0x6ef326c600000000lu;
[[maybe_unused]]
constexpr uint64_t kReadOnlyLog_Get_GenOrdinal = 0x6f3ceba5eca871fflu;
extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetResponseTable;

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

ReadOnlyLog::ResultOf::Get ReadOnlyLog::SyncClient::Get() {
    return ResultOf::Get(::zx::unowned_channel(this->channel_));
}

ReadOnlyLog::ResultOf::Get ReadOnlyLog::Call::Get(::zx::unowned_channel _client_end) {
  return ResultOf::Get(std::move(_client_end));
}

template <>
ReadOnlyLog::UnownedResultOf::Get_Impl<ReadOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      ReadOnlyLog::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


bool ReadOnlyLog::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 kReadOnlyLog_Get_Ordinal:
    case kReadOnlyLog_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Get(
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void ReadOnlyLog::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::debuglog log) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  ReadOnlyLog::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.log = std::move(log);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void ReadOnlyLog::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  ReadOnlyLog::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void ReadOnlyLog::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<ReadOnlyLog::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kReadOnlyLog_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void ReadOnlyLog::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<ReadOnlyLog::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kReadOnlyLog_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kItems_Get_Ordinal = 0x6462c85400000000lu;
[[maybe_unused]]
constexpr uint64_t kItems_Get_GenOrdinal = 0x542db3f176641edclu;
extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetResponseTable;

}  // namespace
template <>
Items::ResultOf::Get_Impl<Items::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetRequest*>(_write_bytes);
  _request.type = std::move(type);
  _request.extra = std::move(extra);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      Items::InPlace::Get(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Items::ResultOf::Get Items::SyncClient::Get(uint32_t type, uint32_t extra) {
    return ResultOf::Get(::zx::unowned_channel(this->channel_), std::move(type), std::move(extra));
}

Items::ResultOf::Get Items::Call::Get(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra) {
  return ResultOf::Get(std::move(_client_end), std::move(type), std::move(extra));
}

template <>
Items::UnownedResultOf::Get_Impl<Items::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetRequest*>(_request_buffer.data());
  _request.type = std::move(type);
  _request.extra = std::move(extra);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Items::InPlace::Get(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Items::UnownedResultOf::Get Items::SyncClient::Get(::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(extra), std::move(_response_buffer));
}

Items::UnownedResultOf::Get Items::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Get(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(extra), std::move(_response_buffer));
}

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


bool Items::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 kItems_Get_Ordinal:
    case kItems_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Get(std::move(message->type), std::move(message->extra),
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void Items::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  Items::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.payload = std::move(payload);
  _response.length = std::move(length);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void Items::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  Items::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void Items::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<Items::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kItems_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Items::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<Items::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kItems_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kFactoryItems_Get_Ordinal = 0x18be2c3500000000lu;
[[maybe_unused]]
constexpr uint64_t kFactoryItems_Get_GenOrdinal = 0x2f0dcb1aba41b6d9lu;
extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetResponseTable;

}  // namespace
template <>
FactoryItems::ResultOf::Get_Impl<FactoryItems::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, uint32_t extra) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::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, GetRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetRequest*>(_write_bytes);
  _request.extra = std::move(extra);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
  Super::SetResult(
      FactoryItems::InPlace::Get(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

FactoryItems::ResultOf::Get FactoryItems::SyncClient::Get(uint32_t extra) {
    return ResultOf::Get(::zx::unowned_channel(this->channel_), std::move(extra));
}

FactoryItems::ResultOf::Get FactoryItems::Call::Get(::zx::unowned_channel _client_end, uint32_t extra) {
  return ResultOf::Get(std::move(_client_end), std::move(extra));
}

template <>
FactoryItems::UnownedResultOf::Get_Impl<FactoryItems::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < GetRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<GetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  auto& _request = *reinterpret_cast<GetRequest*>(_request_buffer.data());
  _request.extra = std::move(extra);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      FactoryItems::InPlace::Get(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

FactoryItems::UnownedResultOf::Get FactoryItems::SyncClient::Get(::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(extra), std::move(_response_buffer));
}

FactoryItems::UnownedResultOf::Get FactoryItems::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::Get(std::move(_client_end), std::move(_request_buffer), std::move(extra), std::move(_response_buffer));
}

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


bool FactoryItems::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 kFactoryItems_Get_Ordinal:
    case kFactoryItems_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->Get(std::move(message->extra),
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void FactoryItems::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  FactoryItems::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.payload = std::move(payload);
  _response.length = std::move(length);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void FactoryItems::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  FactoryItems::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void FactoryItems::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<FactoryItems::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kFactoryItems_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void FactoryItems::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<FactoryItems::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kFactoryItems_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kRootResource_Get_Ordinal = 0x2e9e3a1400000000lu;
[[maybe_unused]]
constexpr uint64_t kRootResource_Get_GenOrdinal = 0x5a1df646e4df6f78lu;
extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetResponseTable;

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

RootResource::ResultOf::Get RootResource::SyncClient::Get() {
    return ResultOf::Get(::zx::unowned_channel(this->channel_));
}

RootResource::ResultOf::Get RootResource::Call::Get(::zx::unowned_channel _client_end) {
  return ResultOf::Get(std::move(_client_end));
}

template <>
RootResource::UnownedResultOf::Get_Impl<RootResource::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      RootResource::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


bool RootResource::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 kRootResource_Get_Ordinal:
    case kRootResource_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Get(
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void RootResource::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::resource resource) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  RootResource::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.resource = std::move(resource);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void RootResource::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  RootResource::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void RootResource::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootResource::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootResource_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void RootResource::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootResource::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootResource_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kRootJob_Get_Ordinal = 0x7e473a2400000000lu;
[[maybe_unused]]
constexpr uint64_t kRootJob_Get_GenOrdinal = 0x70e2566b29e1af06lu;
extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetResponseTable;

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

RootJob::ResultOf::Get RootJob::SyncClient::Get() {
    return ResultOf::Get(::zx::unowned_channel(this->channel_));
}

RootJob::ResultOf::Get RootJob::Call::Get(::zx::unowned_channel _client_end) {
  return ResultOf::Get(std::move(_client_end));
}

template <>
RootJob::UnownedResultOf::Get_Impl<RootJob::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      RootJob::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


bool RootJob::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 kRootJob_Get_Ordinal:
    case kRootJob_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Get(
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void RootJob::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::job job) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  RootJob::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.job = std::move(job);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void RootJob::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  RootJob::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void RootJob::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootJob::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJob_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void RootJob::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootJob::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJob_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kRootJobForInspect_Get_Ordinal = 0x7e473a2400000000lu;
[[maybe_unused]]
constexpr uint64_t kRootJobForInspect_Get_GenOrdinal = 0x70e2566b29e1af06lu;
extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetResponseTable;

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

RootJobForInspect::ResultOf::Get RootJobForInspect::SyncClient::Get() {
    return ResultOf::Get(::zx::unowned_channel(this->channel_));
}

RootJobForInspect::ResultOf::Get RootJobForInspect::Call::Get(::zx::unowned_channel _client_end) {
  return ResultOf::Get(std::move(_client_end));
}

template <>
RootJobForInspect::UnownedResultOf::Get_Impl<RootJobForInspect::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      RootJobForInspect::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


bool RootJobForInspect::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 kRootJobForInspect_Get_Ordinal:
    case kRootJobForInspect_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Get(
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void RootJobForInspect::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::job job) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  RootJobForInspect::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.job = std::move(job);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void RootJobForInspect::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  RootJobForInspect::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void RootJobForInspect::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootJobForInspect::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJobForInspect_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void RootJobForInspect::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootJobForInspect::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJobForInspect_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

namespace {

[[maybe_unused]]
constexpr uint64_t kArguments_Get_Ordinal = 0x6e7258e600000000lu;
[[maybe_unused]]
constexpr uint64_t kArguments_Get_GenOrdinal = 0x2e594d9c82b93ee3lu;
extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetRequestTable;
extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetResponseTable;

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

Arguments::ResultOf::Get Arguments::SyncClient::Get() {
    return ResultOf::Get(::zx::unowned_channel(this->channel_));
}

Arguments::ResultOf::Get Arguments::Call::Get(::zx::unowned_channel _client_end) {
  return ResultOf::Get(std::move(_client_end));
}

template <>
Arguments::UnownedResultOf::Get_Impl<Arguments::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetRequest));
  ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Arguments::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


bool Arguments::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 kArguments_Get_Ordinal:
    case kArguments_Get_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->Get(
          Interface::GetCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

void Arguments::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size) {
  if (_buffer.capacity() < GetResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
  Arguments::SetTransactionHeaderFor::GetResponse(
      ::fidl::DecodedMessage<GetResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetResponse::PrimarySize,
              GetResponse::PrimarySize)));
  _response.vmo = std::move(vmo);
  _response.size = std::move(size);
  _buffer.set_actual(sizeof(GetResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
}

void Arguments::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
  Arguments::SetTransactionHeaderFor::GetResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void Arguments::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<Arguments::GetRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kArguments_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Arguments::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<Arguments::GetResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kArguments_Get_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

}  // namespace boot
}  // namespace fuchsia
}  // namespace llcpp