tools/fidl/fidlgen_hlcpp/goldens/natural_types/error.cc.golden

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

#include <fidl/test/error/cpp/natural_types.h>

#include "lib/fidl/cpp/internal/natural_types_implementation.h"

//
// Domain objects definitions (i.e. "natural types" in unified bindings)
//
namespace fidl {
namespace test {
namespace error {
extern "C" const fidl_type_t fidl_test_error_Example_foo_ResponseTable;
const fidl_type_t* Example_foo_Response::FidlType =
    &fidl_test_error_Example_foo_ResponseTable;

void Example_foo_Response::Encode(
    ::fidl::Encoder* _encoder, size_t _offset,
    cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  if (::fidl::IsMemcpyCompatible<Example_foo_Response>::value) {
    memcpy(_encoder->template GetPtr<Example_foo_Response>(_offset), this,
           sizeof(Example_foo_Response));
  } else {
    ::fidl::Encode(_encoder, &y, _offset + 0);
  }
}

void Example_foo_Response::Decode(::fidl::Decoder* _decoder,
                                  Example_foo_Response* _value,
                                  size_t _offset) {
  if (::fidl::IsMemcpyCompatible<Example_foo_Response>::value) {
    memcpy(_value, _decoder->template GetPtr<Example_foo_Response>(_offset),
           sizeof(Example_foo_Response));
  } else {
    ::fidl::Decode(_decoder, &_value->y, _offset + 0);
  }
}

zx_status_t Example_foo_Response::Clone(Example_foo_Response* _result) const {
  zx_status_t _status = ::fidl::Clone(y, &_result->y);
  if (_status != ZX_OK) return _status;
  return ZX_OK;
}

extern "C" const fidl_type_t fidl_test_error_Example_foo_ResultTable;
const fidl_type_t* Example_foo_Result::FidlType =
    &fidl_test_error_Example_foo_ResultTable;

Example_foo_Result::Example_foo_Result() {}

Example_foo_Result::~Example_foo_Result() { Destroy(); }

Example_foo_Result::Example_foo_Result(Example_foo_Result&& other)
    : tag_(other.tag_) {
  switch (tag_) {
    case ::fidl::test::error::Example_foo_Result::Tag::kResponse:
      new (&response_)::fidl::test::error::Example_foo_Response();
      response_ = std::move(other.response_);
      break;
    case ::fidl::test::error::Example_foo_Result::Tag::kErr:
      err_ = std::move(other.err_);
      break;
    case static_cast<fidl_xunion_tag_t>(
        ::fidl::test::error::Example_foo_Result::Tag::Invalid):
      break;
  }
}

Example_foo_Result& Example_foo_Result::operator=(Example_foo_Result&& other) {
  if (this != &other) {
    Destroy();
    tag_ = other.tag_;
    switch (tag_) {
      case ::fidl::test::error::Example_foo_Result::Tag::kResponse:
        new (&response_)::fidl::test::error::Example_foo_Response();
        response_ = std::move(other.response_);
        break;
      case ::fidl::test::error::Example_foo_Result::Tag::kErr:
        err_ = std::move(other.err_);
        break;
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::error::Example_foo_Result::Tag::Invalid):
        break;
    }
  }
  return *this;
}

Example_foo_Result Example_foo_Result::WithResponse(
    ::fidl::test::error::Example_foo_Response&& val) {
  Example_foo_Result result;
  result.set_response(std::move(val));
  return result;
}
Example_foo_Result Example_foo_Result::WithErr(uint32_t&& val) {
  Example_foo_Result result;
  result.set_err(std::move(val));
  return result;
}

void Example_foo_Result::Encode(
    ::fidl::Encoder* encoder, size_t offset,
    cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
  const size_t length_before = encoder->CurrentLength();
  const size_t handles_before = encoder->CurrentHandleCount();

  size_t envelope_offset = 0;

  switch (Which()) {
    case ::fidl::test::error::Example_foo_Result::Tag::kResponse: {
      envelope_offset = encoder->Alloc(
          ::fidl::EncodingInlineSize<::fidl::test::error::Example_foo_Response,
                                     ::fidl::Encoder>(encoder));
      ::fidl::Encode(encoder, &response_, envelope_offset);
      break;
    }
    case ::fidl::test::error::Example_foo_Result::Tag::kErr: {
      envelope_offset = encoder->Alloc(
          ::fidl::EncodingInlineSize<uint32_t, ::fidl::Encoder>(encoder));
      ::fidl::Encode(encoder, &err_, envelope_offset);
      break;
    }
    default:
      break;
  }

  fidl_xunion_t* xunion = encoder->GetPtr<fidl_xunion_t>(offset);
  assert(xunion->envelope.presence == FIDL_ALLOC_ABSENT);

  if (envelope_offset) {
    xunion->tag = tag_;
    xunion->envelope.num_bytes =
        static_cast<uint32_t>(encoder->CurrentLength() - length_before);
    xunion->envelope.num_handles =
        static_cast<uint32_t>(encoder->CurrentHandleCount() - handles_before);
    xunion->envelope.presence = FIDL_ALLOC_PRESENT;
  }
}

void Example_foo_Result::Decode(::fidl::Decoder* decoder,
                                Example_foo_Result* value, size_t offset) {
  fidl_xunion_t* xunion = decoder->GetPtr<fidl_xunion_t>(offset);

  if (!xunion->envelope.data) {
    value->EnsureStorageInitialized(static_cast<fidl_xunion_tag_t>(
        ::fidl::test::error::Example_foo_Result::Tag::Invalid));
    return;
  }

  value->EnsureStorageInitialized(xunion->tag);

  const size_t envelope_offset = decoder->GetOffset(xunion->envelope.data);

  switch (value->tag_) {
    case ::fidl::test::error::Example_foo_Result::Tag::kResponse:
      new (&value->response_)::fidl::test::error::Example_foo_Response();
      ::fidl::Decode(decoder, &value->response_, envelope_offset);
      break;
    case ::fidl::test::error::Example_foo_Result::Tag::kErr:
      ::fidl::Decode(decoder, &value->err_, envelope_offset);
      break;
    default:
      break;
  }
}

zx_status_t Example_foo_Result::Clone(Example_foo_Result* result) const {
  result->Destroy();
  result->tag_ = tag_;
  switch (tag_) {
    case ::fidl::test::error::Example_foo_Result::Tag::Invalid:
      return ZX_OK;
    case ::fidl::test::error::Example_foo_Result::Tag::kResponse:
      new (&result->response_)::fidl::test::error::Example_foo_Response();
      return ::fidl::Clone(response_, &result->response_);
    case ::fidl::test::error::Example_foo_Result::Tag::kErr:
      return ::fidl::Clone(err_, &result->err_);
    default:
      return ZX_OK;
  }
}

Example_foo_Result& Example_foo_Result::set_response(
    ::fidl::test::error::Example_foo_Response value) {
  EnsureStorageInitialized(
      ::fidl::test::error::Example_foo_Result::Tag::kResponse);
  response_ = std::move(value);
  return *this;
}

Example_foo_Result& Example_foo_Result::set_err(uint32_t value) {
  EnsureStorageInitialized(::fidl::test::error::Example_foo_Result::Tag::kErr);
  err_ = std::move(value);
  return *this;
}

void Example_foo_Result::Destroy() {
  switch (tag_) {
    case ::fidl::test::error::Example_foo_Result::Tag::kResponse:
      response_.~decltype(response_)();
      break;
    case ::fidl::test::error::Example_foo_Result::Tag::kErr:
      break;

    default:
      break;
  }
  tag_ = static_cast<fidl_xunion_tag_t>(
      ::fidl::test::error::Example_foo_Result::Tag::Invalid);
}

void Example_foo_Result::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
  if (tag_ != tag) {
    Destroy();
    tag_ = tag;
    switch (tag_) {
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::error::Example_foo_Result::Tag::Invalid):
        break;
      case ::fidl::test::error::Example_foo_Result::Tag::kResponse:
        new (&response_)::fidl::test::error::Example_foo_Response();
        break;
      case ::fidl::test::error::Example_foo_Result::Tag::kErr:
        new (&err_) uint32_t();
        break;
      default:
        break;
    }
  }
}

}  // namespace error
}  // namespace test
}  // namespace fidl