system/utest/fidl-llcpp-interop/generated/fidl_llcpp_basictypes.cpp

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

#include <fidl_llcpp_basictypes.h>
#include <memory>

namespace fidl {
namespace test {
namespace llcpp {
namespace basictypes {

void ::fidl::test::llcpp::basictypes::SimpleUnion::SizeAndOffsetAssertionHelper() {
  static_assert(offsetof(::fidl::test::llcpp::basictypes::SimpleUnion, field_a_) == 4);
  static_assert(offsetof(::fidl::test::llcpp::basictypes::SimpleUnion, field_b_) == 4);
  static_assert(sizeof(::fidl::test::llcpp::basictypes::SimpleUnion) == ::fidl::test::llcpp::basictypes::SimpleUnion::PrimarySize);
}

namespace {

[[maybe_unused]]
constexpr uint32_t kTestInterface_ConsumeSimpleStruct_Ordinal = 728053387u;
extern "C" const fidl_type_t fidl_test_llcpp_basictypes_TestInterfaceConsumeSimpleStructRequestTable;
[[maybe_unused]]
constexpr uint32_t kTestInterface_ConsumeSimpleUnion_Ordinal = 776403313u;

}  // namespace

zx_status_t TestInterface::SyncClient::ConsumeSimpleStruct(SimpleStruct arg, int32_t* out_status, int32_t* out_field) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeSimpleStructRequest>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _request = *reinterpret_cast<ConsumeSimpleStructRequest*>(_write_bytes);
  _request._hdr.ordinal = kTestInterface_ConsumeSimpleStruct_Ordinal;
  _request.arg = std::move(arg);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConsumeSimpleStructRequest));
  ::fidl::DecodedMessage<ConsumeSimpleStructRequest> _decoded_request(std::move(_request_bytes));
  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
  if (_encode_request_result.status != ZX_OK) {
    return _encode_request_result.status;
  }

  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeSimpleStructResponse>();
  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
  auto _call_result = ::fidl::Call<ConsumeSimpleStructRequest, ConsumeSimpleStructResponse>(
    this->channel_, std::move(_encode_request_result.message), std::move(_response_bytes));
  if (_call_result.status != ZX_OK) {
    return _call_result.status;
  }
  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
  if (_decode_result.status != ZX_OK) {
    return _decode_result.status;
  }
  auto& _response = *_decode_result.message.message();
  *out_status = std::move(_response.status);
  *out_field = std::move(_response.field);
  return ZX_OK;
}

zx_status_t TestInterface::SyncClient::ConsumeSimpleStruct(::fidl::BytePart _request_buffer, SimpleStruct arg, ::fidl::BytePart _response_buffer, int32_t* out_status, int32_t* out_field) {
  auto& _request = *reinterpret_cast<ConsumeSimpleStructRequest*>(_request_buffer.data());
  _request._hdr.ordinal = kTestInterface_ConsumeSimpleStruct_Ordinal;
  _request.arg = std::move(arg);
  _request_buffer.set_actual(sizeof(ConsumeSimpleStructRequest));
  ::fidl::DecodedMessage<ConsumeSimpleStructRequest> _decoded_request(std::move(_request_buffer));
  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
  if (_encode_request_result.status != ZX_OK) {
    return _encode_request_result.status;
  }
  auto _call_result = ::fidl::Call<ConsumeSimpleStructRequest, ConsumeSimpleStructResponse>(
    this->channel_, std::move(_encode_request_result.message), std::move(_response_buffer));
  if (_call_result.status != ZX_OK) {
    return _call_result.status;
  }
  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
  if (_decode_result.status != ZX_OK) {
    return _decode_result.status;
  }
  auto& _response = *_decode_result.message.message();
  *out_status = std::move(_response.status);
  *out_field = std::move(_response.field);
  return ZX_OK;
}

::fidl::DecodeResult<TestInterface::ConsumeSimpleStructResponse> TestInterface::SyncClient::ConsumeSimpleStruct(::fidl::DecodedMessage<ConsumeSimpleStructRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kTestInterface_ConsumeSimpleStruct_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<TestInterface::ConsumeSimpleStructResponse>(
      _encode_request_result.status,
      _encode_request_result.error,
      ::fidl::DecodedMessage<TestInterface::ConsumeSimpleStructResponse>());
  }
  auto _call_result = ::fidl::Call<ConsumeSimpleStructRequest, ConsumeSimpleStructResponse>(
    this->channel_, std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<TestInterface::ConsumeSimpleStructResponse>(
      _call_result.status,
      _call_result.error,
      ::fidl::DecodedMessage<TestInterface::ConsumeSimpleStructResponse>());
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


zx_status_t TestInterface::SyncClient::ConsumeSimpleUnion(SimpleUnion arg, uint32_t* out_index, int32_t* out_field) {
  constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeSimpleUnionRequest>();
  FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
  auto& _request = *reinterpret_cast<ConsumeSimpleUnionRequest*>(_write_bytes);
  _request._hdr.ordinal = kTestInterface_ConsumeSimpleUnion_Ordinal;
  _request.arg = std::move(arg);
  ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConsumeSimpleUnionRequest));
  ::fidl::DecodedMessage<ConsumeSimpleUnionRequest> _decoded_request(std::move(_request_bytes));
  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
  if (_encode_request_result.status != ZX_OK) {
    return _encode_request_result.status;
  }

  constexpr uint32_t _kReadAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeSimpleUnionResponse>();
  FIDL_ALIGNDECL uint8_t _read_bytes[_kReadAllocSize];
  ::fidl::BytePart _response_bytes(_read_bytes, _kReadAllocSize);
  auto _call_result = ::fidl::Call<ConsumeSimpleUnionRequest, ConsumeSimpleUnionResponse>(
    this->channel_, std::move(_encode_request_result.message), std::move(_response_bytes));
  if (_call_result.status != ZX_OK) {
    return _call_result.status;
  }
  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
  if (_decode_result.status != ZX_OK) {
    return _decode_result.status;
  }
  auto& _response = *_decode_result.message.message();
  *out_index = std::move(_response.index);
  *out_field = std::move(_response.field);
  return ZX_OK;
}

zx_status_t TestInterface::SyncClient::ConsumeSimpleUnion(::fidl::BytePart _request_buffer, SimpleUnion arg, ::fidl::BytePart _response_buffer, uint32_t* out_index, int32_t* out_field) {
  auto& _request = *reinterpret_cast<ConsumeSimpleUnionRequest*>(_request_buffer.data());
  _request._hdr.ordinal = kTestInterface_ConsumeSimpleUnion_Ordinal;
  _request.arg = std::move(arg);
  _request_buffer.set_actual(sizeof(ConsumeSimpleUnionRequest));
  ::fidl::DecodedMessage<ConsumeSimpleUnionRequest> _decoded_request(std::move(_request_buffer));
  auto _encode_request_result = ::fidl::Encode(std::move(_decoded_request));
  if (_encode_request_result.status != ZX_OK) {
    return _encode_request_result.status;
  }
  auto _call_result = ::fidl::Call<ConsumeSimpleUnionRequest, ConsumeSimpleUnionResponse>(
    this->channel_, std::move(_encode_request_result.message), std::move(_response_buffer));
  if (_call_result.status != ZX_OK) {
    return _call_result.status;
  }
  auto _decode_result = ::fidl::Decode(std::move(_call_result.message));
  if (_decode_result.status != ZX_OK) {
    return _decode_result.status;
  }
  auto& _response = *_decode_result.message.message();
  *out_index = std::move(_response.index);
  *out_field = std::move(_response.field);
  return ZX_OK;
}

::fidl::DecodeResult<TestInterface::ConsumeSimpleUnionResponse> TestInterface::SyncClient::ConsumeSimpleUnion(::fidl::DecodedMessage<ConsumeSimpleUnionRequest> params, ::fidl::BytePart response_buffer) {
  params.message()->_hdr = {};
  params.message()->_hdr.ordinal = kTestInterface_ConsumeSimpleUnion_Ordinal;
  auto _encode_request_result = ::fidl::Encode(std::move(params));
  if (_encode_request_result.status != ZX_OK) {
    return ::fidl::DecodeResult<TestInterface::ConsumeSimpleUnionResponse>(
      _encode_request_result.status,
      _encode_request_result.error,
      ::fidl::DecodedMessage<TestInterface::ConsumeSimpleUnionResponse>());
  }
  auto _call_result = ::fidl::Call<ConsumeSimpleUnionRequest, ConsumeSimpleUnionResponse>(
    this->channel_, std::move(_encode_request_result.message), std::move(response_buffer));
  if (_call_result.status != ZX_OK) {
    return ::fidl::DecodeResult<TestInterface::ConsumeSimpleUnionResponse>(
      _call_result.status,
      _call_result.error,
      ::fidl::DecodedMessage<TestInterface::ConsumeSimpleUnionResponse>());
  }
  return ::fidl::Decode(std::move(_call_result.message));
}


}  // namespace basictypes
}  // namespace llcpp
}  // namespace test
}  // namespace fidl