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

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

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

namespace llcpp {

namespace fidl {
namespace test {
namespace json {

void ::llcpp::fidl::test::json::StrictFoo::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(StrictFoo) == sizeof(fidl_xunion_t));
  static_assert(offsetof(StrictFoo, ordinal_) == offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(StrictFoo, envelope_) == offsetof(fidl_xunion_t, envelope));
}
auto ::llcpp::fidl::test::json::FlexibleFoo::which() const -> Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
  case Ordinal::kS:
  case Ordinal::kI:
    return static_cast<Tag>(ordinal_);
  default:
    return Tag::kUnknown;
  }
}

void ::llcpp::fidl::test::json::FlexibleFoo::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(FlexibleFoo) == sizeof(fidl_xunion_t));
  static_assert(offsetof(FlexibleFoo, ordinal_) == offsetof(fidl_xunion_t, tag));
  static_assert(offsetof(FlexibleFoo, envelope_) == offsetof(fidl_xunion_t, envelope));
}

namespace {

[[maybe_unused]]
constexpr uint64_t kProtocol_RequestStrictResponseFlexible_Ordinal = 0x1143e3c200000000lu;
[[maybe_unused]]
constexpr uint64_t kProtocol_RequestStrictResponseFlexible_GenOrdinal = 0x72b1a46e5e2af282lu;
extern "C" const fidl_type_t v1_fidl_test_json_ProtocolRequestStrictResponseFlexibleRequestTable;
extern "C" const fidl_type_t v1_fidl_test_json_ProtocolRequestStrictResponseFlexibleResponseTable;
[[maybe_unused]]
constexpr uint64_t kProtocol_RequestFlexibleResponseStrict_Ordinal = 0x3136aeff00000000lu;
[[maybe_unused]]
constexpr uint64_t kProtocol_RequestFlexibleResponseStrict_GenOrdinal = 0x42a34ad5c4a1d952lu;
extern "C" const fidl_type_t v1_fidl_test_json_ProtocolRequestFlexibleResponseStrictRequestTable;
extern "C" const fidl_type_t v1_fidl_test_json_ProtocolRequestFlexibleResponseStrictResponseTable;

}  // namespace
template <>
Protocol::ResultOf::RequestStrictResponseFlexible_Impl<Protocol::RequestStrictResponseFlexibleResponse>::RequestStrictResponseFlexible_Impl(::zx::unowned_channel _client_end, ::llcpp::fidl::test::json::StrictFoo s) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RequestStrictResponseFlexibleRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  RequestStrictResponseFlexibleRequest _request = {};
  _request.s = std::move(s);
  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<RequestStrictResponseFlexibleRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Protocol::InPlace::RequestStrictResponseFlexible(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Protocol::ResultOf::RequestStrictResponseFlexible Protocol::SyncClient::RequestStrictResponseFlexible(::llcpp::fidl::test::json::StrictFoo s) {
    return ResultOf::RequestStrictResponseFlexible(::zx::unowned_channel(this->channel_), std::move(s));
}

Protocol::ResultOf::RequestStrictResponseFlexible Protocol::Call::RequestStrictResponseFlexible(::zx::unowned_channel _client_end, ::llcpp::fidl::test::json::StrictFoo s) {
  return ResultOf::RequestStrictResponseFlexible(std::move(_client_end), std::move(s));
}

template <>
Protocol::UnownedResultOf::RequestStrictResponseFlexible_Impl<Protocol::RequestStrictResponseFlexibleResponse>::RequestStrictResponseFlexible_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::json::StrictFoo s, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < RequestStrictResponseFlexibleRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<RequestStrictResponseFlexibleResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  RequestStrictResponseFlexibleRequest _request = {};
  _request.s = std::move(s);
  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<RequestStrictResponseFlexibleRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Protocol::InPlace::RequestStrictResponseFlexible(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Protocol::UnownedResultOf::RequestStrictResponseFlexible Protocol::SyncClient::RequestStrictResponseFlexible(::fidl::BytePart _request_buffer, ::llcpp::fidl::test::json::StrictFoo s, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RequestStrictResponseFlexible(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(s), std::move(_response_buffer));
}

Protocol::UnownedResultOf::RequestStrictResponseFlexible Protocol::Call::RequestStrictResponseFlexible(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::json::StrictFoo s, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RequestStrictResponseFlexible(std::move(_client_end), std::move(_request_buffer), std::move(s), std::move(_response_buffer));
}

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

template <>
Protocol::ResultOf::RequestFlexibleResponseStrict_Impl<Protocol::RequestFlexibleResponseStrictResponse>::RequestFlexibleResponseStrict_Impl(::zx::unowned_channel _client_end, ::llcpp::fidl::test::json::FlexibleFoo s) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RequestFlexibleResponseStrictRequest, ::fidl::MessageDirection::kSending>();
  std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
  auto& _write_bytes_array = *_write_bytes_boxed;
  RequestFlexibleResponseStrictRequest _request = {};
  _request.s = std::move(s);
  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<RequestFlexibleResponseStrictRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Protocol::InPlace::RequestFlexibleResponseStrict(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
}

Protocol::ResultOf::RequestFlexibleResponseStrict Protocol::SyncClient::RequestFlexibleResponseStrict(::llcpp::fidl::test::json::FlexibleFoo s) {
    return ResultOf::RequestFlexibleResponseStrict(::zx::unowned_channel(this->channel_), std::move(s));
}

Protocol::ResultOf::RequestFlexibleResponseStrict Protocol::Call::RequestFlexibleResponseStrict(::zx::unowned_channel _client_end, ::llcpp::fidl::test::json::FlexibleFoo s) {
  return ResultOf::RequestFlexibleResponseStrict(std::move(_client_end), std::move(s));
}

template <>
Protocol::UnownedResultOf::RequestFlexibleResponseStrict_Impl<Protocol::RequestFlexibleResponseStrictResponse>::RequestFlexibleResponseStrict_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::json::FlexibleFoo s, ::fidl::BytePart _response_buffer) {
  if (_request_buffer.capacity() < RequestFlexibleResponseStrictRequest::PrimarySize) {
    Super::SetFailure(::fidl::DecodeResult<RequestFlexibleResponseStrictResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
    return;
  }
  RequestFlexibleResponseStrictRequest _request = {};
  _request.s = std::move(s);
  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<RequestFlexibleResponseStrictRequest> _decoded_request = std::move(_linearize_result.message);
  Super::SetResult(
      Protocol::InPlace::RequestFlexibleResponseStrict(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
}

Protocol::UnownedResultOf::RequestFlexibleResponseStrict Protocol::SyncClient::RequestFlexibleResponseStrict(::fidl::BytePart _request_buffer, ::llcpp::fidl::test::json::FlexibleFoo s, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RequestFlexibleResponseStrict(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(s), std::move(_response_buffer));
}

Protocol::UnownedResultOf::RequestFlexibleResponseStrict Protocol::Call::RequestFlexibleResponseStrict(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::json::FlexibleFoo s, ::fidl::BytePart _response_buffer) {
  return UnownedResultOf::RequestFlexibleResponseStrict(std::move(_client_end), std::move(_request_buffer), std::move(s), std::move(_response_buffer));
}

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


bool Protocol::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 kProtocol_RequestStrictResponseFlexible_Ordinal:
    case kProtocol_RequestStrictResponseFlexible_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<RequestStrictResponseFlexibleRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->RequestStrictResponseFlexible(std::move(message->s),
          Interface::RequestStrictResponseFlexibleCompleter::Sync(txn));
      return true;
    }
    case kProtocol_RequestFlexibleResponseStrict_Ordinal:
    case kProtocol_RequestFlexibleResponseStrict_GenOrdinal:
    {
      auto result = ::fidl::DecodeAs<RequestFlexibleResponseStrictRequest>(msg);
      if (result.status != ZX_OK) {
        txn->Close(ZX_ERR_INVALID_ARGS);
        return true;
      }
      auto message = result.message.message();
      impl->RequestFlexibleResponseStrict(std::move(message->s),
          Interface::RequestFlexibleResponseStrictCompleter::Sync(txn));
      return true;
    }
    default: {
      return false;
    }
  }
}

bool Protocol::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 Protocol::Interface::RequestStrictResponseFlexibleCompleterBase::Reply(::llcpp::fidl::test::json::FlexibleFoo f) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RequestStrictResponseFlexibleResponse, ::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();
  RequestStrictResponseFlexibleResponse _response = {};
  Protocol::SetTransactionHeaderFor::RequestStrictResponseFlexibleResponse(
      ::fidl::DecodedMessage<RequestStrictResponseFlexibleResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              RequestStrictResponseFlexibleResponse::PrimarySize,
              RequestStrictResponseFlexibleResponse::PrimarySize)));
  _response.f = std::move(f);
  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 Protocol::Interface::RequestStrictResponseFlexibleCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fidl::test::json::FlexibleFoo f) {
  if (_buffer.capacity() < RequestStrictResponseFlexibleResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  RequestStrictResponseFlexibleResponse _response = {};
  Protocol::SetTransactionHeaderFor::RequestStrictResponseFlexibleResponse(
      ::fidl::DecodedMessage<RequestStrictResponseFlexibleResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              RequestStrictResponseFlexibleResponse::PrimarySize,
              RequestStrictResponseFlexibleResponse::PrimarySize)));
  _response.f = std::move(f);
  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 Protocol::Interface::RequestStrictResponseFlexibleCompleterBase::Reply(::fidl::DecodedMessage<RequestStrictResponseFlexibleResponse> params) {
  Protocol::SetTransactionHeaderFor::RequestStrictResponseFlexibleResponse(params);
  CompleterBase::SendReply(std::move(params));
}


void Protocol::Interface::RequestFlexibleResponseStrictCompleterBase::Reply(::llcpp::fidl::test::json::StrictFoo f) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RequestFlexibleResponseStrictResponse, ::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();
  RequestFlexibleResponseStrictResponse _response = {};
  Protocol::SetTransactionHeaderFor::RequestFlexibleResponseStrictResponse(
      ::fidl::DecodedMessage<RequestFlexibleResponseStrictResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              RequestFlexibleResponseStrictResponse::PrimarySize,
              RequestFlexibleResponseStrictResponse::PrimarySize)));
  _response.f = std::move(f);
  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 Protocol::Interface::RequestFlexibleResponseStrictCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fidl::test::json::StrictFoo f) {
  if (_buffer.capacity() < RequestFlexibleResponseStrictResponse::PrimarySize) {
    CompleterBase::Close(ZX_ERR_INTERNAL);
    return;
  }
  RequestFlexibleResponseStrictResponse _response = {};
  Protocol::SetTransactionHeaderFor::RequestFlexibleResponseStrictResponse(
      ::fidl::DecodedMessage<RequestFlexibleResponseStrictResponse>(
          ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
              RequestFlexibleResponseStrictResponse::PrimarySize,
              RequestFlexibleResponseStrictResponse::PrimarySize)));
  _response.f = std::move(f);
  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 Protocol::Interface::RequestFlexibleResponseStrictCompleterBase::Reply(::fidl::DecodedMessage<RequestFlexibleResponseStrictResponse> params) {
  Protocol::SetTransactionHeaderFor::RequestFlexibleResponseStrictResponse(params);
  CompleterBase::SendReply(std::move(params));
}



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

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

}  // namespace json
}  // namespace test
}  // namespace fidl
}  // namespace llcpp