tools/fidl/fidlgen_cpp/goldens/types_in_protocols_wire_types.cc.golden

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

// fidl_experiment = output_index_json

#include <fidl/test.typesinprotocols/cpp/wire_types.h>

#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wshadow"

#ifdef __Fuchsia__
void ::test_typesinprotocols::wire::ResourceStruct::_CloseHandles() {
}

#endif  // __Fuchsia__

#ifdef __Fuchsia__
void ::test_typesinprotocols::wire::Resource::_CloseHandles() {
  handle.reset();
  vmo.reset();
  client_end.reset();
  server_end.reset();
  struct_._CloseHandles();
  table._CloseHandles();
  union_._CloseHandles();
  opt_handle.reset();
  opt_vmo.reset();
  opt_client_end.reset();
  opt_server_end.reset();
  if (opt_struct != nullptr) {
    opt_struct->_CloseHandles();
  }
  if (opt_union.has_value()) {
    opt_union->_CloseHandles();
  }
  for (auto& e_1 : array_handle) {
    e_1.reset();
  }
  for (auto& e_1 : array_vmo) {
    e_1.reset();
  }
  for (auto& e_1 : array_client_end) {
    e_1.reset();
  }
  for (auto& e_1 : array_server_end) {
    e_1.reset();
  }
  for (auto& e_1 : array_struct) {
    e_1._CloseHandles();
  }
  for (auto& e_1 : array_table) {
    e_1._CloseHandles();
  }
  for (auto& e_1 : array_union) {
    e_1._CloseHandles();
  }
  for (auto& e_1 : vector_handle) {
    e_1.reset();
  }
  for (auto& e_1 : vector_vmo) {
    e_1.reset();
  }
  for (auto& e_1 : vector_client_end) {
    e_1.reset();
  }
  for (auto& e_1 : vector_server_end) {
    e_1.reset();
  }
  for (auto& e_1 : vector_struct) {
    e_1._CloseHandles();
  }
  for (auto& e_1 : vector_table) {
    e_1._CloseHandles();
  }
  for (auto& e_1 : vector_union) {
    e_1._CloseHandles();
  }
}

#endif  // __Fuchsia__

auto ::test_typesinprotocols::wire::Union::Which() const -> ::test_typesinprotocols::wire::Union::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_typesinprotocols::wire::Union::Ordinal::kB:
      return static_cast<::test_typesinprotocols::wire::Union::Tag>(ordinal_);
    default:
      return ::test_typesinprotocols::wire::Union::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_typesinprotocols::wire::Union::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(Union) == sizeof(fidl_union_t));
  static_assert(offsetof(Union, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(Union, envelope_) == offsetof(fidl_union_t, envelope));
}

#ifdef __Fuchsia__

auto ::test_typesinprotocols::wire::ResourceUnion::Which() const -> ::test_typesinprotocols::wire::ResourceUnion::Tag {
  ZX_ASSERT(!has_invalid_tag());
  switch (ordinal_) {
    case ::test_typesinprotocols::wire::ResourceUnion::Ordinal::kB:
      return static_cast<::test_typesinprotocols::wire::ResourceUnion::Tag>(ordinal_);
    default:
      return ::test_typesinprotocols::wire::ResourceUnion::Tag::_do_not_handle_this__write_a_default_case_instead;
  }
}

void ::test_typesinprotocols::wire::ResourceUnion::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ResourceUnion) == sizeof(fidl_union_t));
  static_assert(offsetof(ResourceUnion, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ResourceUnion, envelope_) == offsetof(fidl_union_t, envelope));
}
::test_typesinprotocols::wire::ResourceUnion::~ResourceUnion() {
  switch (ordinal_) {
    case ::test_typesinprotocols::wire::ResourceUnion::Ordinal::kB:
      envelope_.As<bool>().clear_data();
      break;
    default:
      break;
  }
}

void ::test_typesinprotocols::wire::ResourceUnion::_Move(ResourceUnion&& other) {
  ordinal_ = other.ordinal_;
  switch (ordinal_) {
    case ::test_typesinprotocols::wire::ResourceUnion::Ordinal::kB:
      envelope_.As<bool>() = std::move(other.envelope_.As<bool>());
      break;
    default:
      break;
  }
}

void ::test_typesinprotocols::wire::ResourceUnion::_CloseHandles() {
  switch (ordinal_) {
    default:
      break;
  }
}

#endif  // __Fuchsia__

void ::test_typesinprotocols::wire::ProtocolErrorBasicResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorBasicResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorBasicResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorBasicResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorCompoundResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorCompoundResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorCompoundResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorArrayBasicResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorArrayBasicResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorArrayBasicResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorArrayCompoundResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorArrayCompoundResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorArrayCompoundResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorVectorBasicResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorVectorBasicResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorVectorBasicResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorVectorCompoundResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorVectorCompoundResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorVectorCompoundResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorVectorOptionalResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorVectorOptionalResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorVectorOptionalResult, envelope_) == offsetof(fidl_union_t, envelope));
}

void ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorArrayVectorNestedResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorArrayVectorNestedResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorArrayVectorNestedResult, envelope_) == offsetof(fidl_union_t, envelope));
}

#ifdef __Fuchsia__

void ::test_typesinprotocols::wire::ProtocolErrorResourceResult::SizeAndOffsetAssertionHelper() {
  static_assert(sizeof(ProtocolErrorResourceResult) == sizeof(fidl_union_t));
  static_assert(offsetof(ProtocolErrorResourceResult, ordinal_) == offsetof(fidl_union_t, tag));
  static_assert(offsetof(ProtocolErrorResourceResult, envelope_) == offsetof(fidl_union_t, envelope));
}
::test_typesinprotocols::wire::ProtocolErrorResourceResult::~ProtocolErrorResourceResult() {
  switch (ordinal_) {
    case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kResponse:
      envelope_.As<::test_typesinprotocols::wire::Resource>().clear_data();
      break;
    case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kErr:
      envelope_.As<uint32_t>().clear_data();
      break;
    default:
      break;
  }
}

void ::test_typesinprotocols::wire::ProtocolErrorResourceResult::_Move(ProtocolErrorResourceResult&& other) {
  ordinal_ = other.ordinal_;
  switch (ordinal_) {
    case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kResponse:
      envelope_.As<::test_typesinprotocols::wire::Resource>() = std::move(other.envelope_.As<::test_typesinprotocols::wire::Resource>());
      break;
    case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kErr:
      envelope_.As<uint32_t>() = std::move(other.envelope_.As<uint32_t>());
      break;
    default:
      break;
  }
}

void ::test_typesinprotocols::wire::ProtocolErrorResourceResult::_CloseHandles() {
  switch (ordinal_) {
    case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kResponse: {
      response()._CloseHandles();
      break;
    }
    default:
      break;
  }
}

#endif  // __Fuchsia__

bool ::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_typesinprotocols::wire::Table>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  return max_ordinal;
}

bool ::test_typesinprotocols::wire::Table::HasUnknownData() const {
  if (max_ordinal_ > 0) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

#ifdef __Fuchsia__

bool ::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>::HasUnknownData() const {
  return false;
}

uint64_t fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>::ComputeMaxOrdinal() const {
  uint64_t max_ordinal = 0;
  return max_ordinal;
}

bool ::test_typesinprotocols::wire::ResourceTable::HasUnknownData() const {
  if (max_ordinal_ > 0) {
    return true;
  }
  if (frame_ptr_ == nullptr) {
    return false;
  }
  return frame_ptr_->HasUnknownData();
}

void ::test_typesinprotocols::wire::ResourceTable::_CloseHandles() {
}

#endif  // __Fuchsia__

#pragma clang diagnostic pop