garnet/go/src/fidl/compiler/backend/goldens/protocol_request.test.json.llcpp.cc.golden

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

#include <protocol_request.test.json.llcpp.h>
#include <memory>

namespace llcpp {

namespace test {
namespace name {

namespace {

[[maybe_unused]]
constexpr uint64_t kParent_GetChild_Ordinal = 0x3692bc6900000000lu;
[[maybe_unused]]
constexpr uint64_t kParent_GetChild_GenOrdinal = 0x57e26ed694158086lu;
extern "C" const fidl_type_t v1_test_name_ParentGetChildRequestTable;
extern "C" const fidl_type_t v1_test_name_ParentGetChildResponseTable;
[[maybe_unused]]
constexpr uint64_t kParent_GetChildRequest_Ordinal = 0x3faacc7e00000000lu;
[[maybe_unused]]
constexpr uint64_t kParent_GetChildRequest_GenOrdinal = 0x5ea0990a698a80lu;
extern "C" const fidl_type_t v1_test_name_ParentGetChildRequestRequestTable;
extern "C" const fidl_type_t v1_test_name_ParentGetChildRequestResponseTable;
[[maybe_unused]]
constexpr uint64_t kParent_TakeChild_Ordinal = 0x4c0642f900000000lu;
[[maybe_unused]]
constexpr uint64_t kParent_TakeChild_GenOrdinal = 0x6a9827d18871f87dlu;
extern "C" const fidl_type_t v1_test_name_ParentTakeChildRequestTable;
extern "C" const fidl_type_t v1_test_name_ParentTakeChildResponseTable;
[[maybe_unused]]
constexpr uint64_t kParent_TakeChildRequest_Ordinal = 0x5ec3867a00000000lu;
[[maybe_unused]]
constexpr uint64_t kParent_TakeChildRequest_GenOrdinal = 0x6c4a70e2a2126637lu;
extern "C" const fidl_type_t v1_test_name_ParentTakeChildRequestRequestTable;
extern "C" const fidl_type_t v1_test_name_ParentTakeChildRequestResponseTable;

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

Parent::ResultOf::GetChild Parent::SyncClient::GetChild() {
    return ResultOf::GetChild(::zx::unowned_channel(this->channel_));
}

Parent::ResultOf::GetChild Parent::Call::GetChild(::zx::unowned_channel _client_end) {
  return ResultOf::GetChild(std::move(_client_end));
}

template <>
Parent::UnownedResultOf::GetChild_Impl<Parent::GetChildResponse>::GetChild_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetChildRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetChildRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetChildRequest));
  ::fidl::DecodedMessage<GetChildRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Parent::InPlace::GetChild(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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

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

Parent::ResultOf::GetChildRequest Parent::SyncClient::GetChildRequest() {
    return ResultOf::GetChildRequest(::zx::unowned_channel(this->channel_));
}

Parent::ResultOf::GetChildRequest Parent::Call::GetChildRequest(::zx::unowned_channel _client_end) {
  return ResultOf::GetChildRequest(std::move(_client_end));
}

template <>
Parent::UnownedResultOf::GetChildRequest_Impl<Parent::GetChildRequestResponse>::GetChildRequest_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
  FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetChildRequestRequest)] = {};
  ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
  memset(_request_buffer.data(), 0, GetChildRequestRequest::PrimarySize);
  _request_buffer.set_actual(sizeof(GetChildRequestRequest));
  ::fidl::DecodedMessage<GetChildRequestRequest> _decoded_request(std::move(_request_buffer));
  Super::SetResult(
      Parent::InPlace::GetChildRequest(std::move(_client_end), std::move(_response_buffer)));
}

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

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

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


Parent::ResultOf::TakeChild_Impl::TakeChild_Impl(::zx::unowned_channel _client_end, ::zx::channel c) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TakeChildRequest, ::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, TakeChildRequest::PrimarySize);
  auto& _request = *reinterpret_cast<TakeChildRequest*>(_write_bytes);
  _request.c = std::move(c);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TakeChildRequest));
  ::fidl::DecodedMessage<TakeChildRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      Parent::InPlace::TakeChild(std::move(_client_end), std::move(_decoded_request)));
}

Parent::ResultOf::TakeChild Parent::SyncClient::TakeChild(::zx::channel c) {
    return ResultOf::TakeChild(::zx::unowned_channel(this->channel_), std::move(c));
}

Parent::ResultOf::TakeChild Parent::Call::TakeChild(::zx::unowned_channel _client_end, ::zx::channel c) {
  return ResultOf::TakeChild(std::move(_client_end), std::move(c));
}


Parent::UnownedResultOf::TakeChild_Impl::TakeChild_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel c) {
  if (_request_buffer.capacity() < TakeChildRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, TakeChildRequest::PrimarySize);
  auto& _request = *reinterpret_cast<TakeChildRequest*>(_request_buffer.data());
  _request.c = std::move(c);
  _request_buffer.set_actual(sizeof(TakeChildRequest));
  ::fidl::DecodedMessage<TakeChildRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      Parent::InPlace::TakeChild(std::move(_client_end), std::move(_decoded_request)));
}

Parent::UnownedResultOf::TakeChild Parent::SyncClient::TakeChild(::fidl::BytePart _request_buffer, ::zx::channel c) {
  return UnownedResultOf::TakeChild(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(c));
}

Parent::UnownedResultOf::TakeChild Parent::Call::TakeChild(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel c) {
  return UnownedResultOf::TakeChild(std::move(_client_end), std::move(_request_buffer), std::move(c));
}

::fidl::internal::StatusAndError Parent::InPlace::TakeChild(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TakeChildRequest> params) {
  Parent::SetTransactionHeaderFor::TakeChildRequest(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);
  }
}


Parent::ResultOf::TakeChildRequest_Impl::TakeChildRequest_Impl(::zx::unowned_channel _client_end, ::zx::channel r) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TakeChildRequestRequest, ::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, TakeChildRequestRequest::PrimarySize);
  auto& _request = *reinterpret_cast<TakeChildRequestRequest*>(_write_bytes);
  _request.r = std::move(r);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TakeChildRequestRequest));
  ::fidl::DecodedMessage<TakeChildRequestRequest> _decoded_request(std::move(_request_bytes));
  Super::operator=(
      Parent::InPlace::TakeChildRequest(std::move(_client_end), std::move(_decoded_request)));
}

Parent::ResultOf::TakeChildRequest Parent::SyncClient::TakeChildRequest(::zx::channel r) {
    return ResultOf::TakeChildRequest(::zx::unowned_channel(this->channel_), std::move(r));
}

Parent::ResultOf::TakeChildRequest Parent::Call::TakeChildRequest(::zx::unowned_channel _client_end, ::zx::channel r) {
  return ResultOf::TakeChildRequest(std::move(_client_end), std::move(r));
}


Parent::UnownedResultOf::TakeChildRequest_Impl::TakeChildRequest_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel r) {
  if (_request_buffer.capacity() < TakeChildRequestRequest::PrimarySize) {
    Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
    Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
    return;
  }
  memset(_request_buffer.data(), 0, TakeChildRequestRequest::PrimarySize);
  auto& _request = *reinterpret_cast<TakeChildRequestRequest*>(_request_buffer.data());
  _request.r = std::move(r);
  _request_buffer.set_actual(sizeof(TakeChildRequestRequest));
  ::fidl::DecodedMessage<TakeChildRequestRequest> _decoded_request(std::move(_request_buffer));
  Super::operator=(
      Parent::InPlace::TakeChildRequest(std::move(_client_end), std::move(_decoded_request)));
}

Parent::UnownedResultOf::TakeChildRequest Parent::SyncClient::TakeChildRequest(::fidl::BytePart _request_buffer, ::zx::channel r) {
  return UnownedResultOf::TakeChildRequest(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(r));
}

Parent::UnownedResultOf::TakeChildRequest Parent::Call::TakeChildRequest(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel r) {
  return UnownedResultOf::TakeChildRequest(std::move(_client_end), std::move(_request_buffer), std::move(r));
}

::fidl::internal::StatusAndError Parent::InPlace::TakeChildRequest(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TakeChildRequestRequest> params) {
  Parent::SetTransactionHeaderFor::TakeChildRequestRequest(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 Parent::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 kParent_GetChild_Ordinal:
    case kParent_GetChild_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetChildRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetChild(
          Interface::GetChildCompleter::Sync(txn));
      return true;
    }
    case kParent_GetChildRequest_Ordinal:
    case kParent_GetChildRequest_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<GetChildRequestRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      impl->GetChildRequest(
          Interface::GetChildRequestCompleter::Sync(txn));
      return true;
    }
    case kParent_TakeChild_Ordinal:
    case kParent_TakeChild_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<TakeChildRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->TakeChild(std::move(message->c),
          Interface::TakeChildCompleter::Sync(txn));
      return true;
    }
    case kParent_TakeChildRequest_Ordinal:
    case kParent_TakeChildRequest_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<TakeChildRequestRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->TakeChildRequest(std::move(message->r),
          Interface::TakeChildRequestCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

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

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

void Parent::Interface::GetChildCompleterBase::Reply(::fidl::DecodedMessage<GetChildResponse> params) {
  Parent::SetTransactionHeaderFor::GetChildResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Parent::Interface::GetChildRequestCompleterBase::Reply(::zx::channel r) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChildRequestResponse, ::fidl::MessageDirection::kSending>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _response = *reinterpret_cast<GetChildRequestResponse*>(_write_bytes);
  Parent::SetTransactionHeaderFor::GetChildRequestResponse(
      ::fidl::DecodedMessage<GetChildRequestResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              GetChildRequestResponse::PrimarySize,
              GetChildRequestResponse::PrimarySize)));
  _response.r = std::move(r);
  ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChildRequestResponse));
  CompleterBase::SendReply(::fidl::DecodedMessage<GetChildRequestResponse>(std::move(_response_bytes)));
}

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

void Parent::Interface::GetChildRequestCompleterBase::Reply(::fidl::DecodedMessage<GetChildRequestResponse> params) {
  Parent::SetTransactionHeaderFor::GetChildRequestResponse(params);
  CompleterBase::SendReply(std::move(params));
}



void Parent::SetTransactionHeaderFor::GetChildRequest(const ::fidl::DecodedMessage<Parent::GetChildRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kParent_GetChild_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Parent::SetTransactionHeaderFor::GetChildResponse(const ::fidl::DecodedMessage<Parent::GetChildResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kParent_GetChild_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

void Parent::SetTransactionHeaderFor::GetChildRequestRequest(const ::fidl::DecodedMessage<Parent::GetChildRequestRequest>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kParent_GetChildRequest_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}
void Parent::SetTransactionHeaderFor::GetChildRequestResponse(const ::fidl::DecodedMessage<Parent::GetChildRequestResponse>& _msg) {
  fidl_init_txn_header(&_msg.message()->_hdr, 0, kParent_GetChildRequest_GenOrdinal);
  _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
}

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

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

namespace {


}  // namespace

}  // namespace name
}  // namespace test
}  // namespace llcpp