tools/fidl/fidlgen_hlcpp/goldens/serializable.cc.golden

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

// fidl_experiment = output_index_json

#include <test/serializable/cpp/fidl.h>

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

//
// Domain objects definitions
//
namespace test {
namespace serializable {

extern "C" const fidl_type_t test_serializable_SerializableStructTable;
const fidl_type_t* SerializableStruct::FidlType = &test_serializable_SerializableStructTable;

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

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

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

extern "C" const fidl_type_t test_serializable_SerializableTableTable;
const fidl_type_t* SerializableTable::FidlType = &test_serializable_SerializableTableTable;

SerializableTable::SerializableTable() {}

SerializableTable::SerializableTable(SerializableTable&& other) {
  field_presence_ = other.field_presence_;
}

SerializableTable::~SerializableTable() {
}

SerializableTable& SerializableTable::operator=(SerializableTable&& other) {
  return *this;
}

bool SerializableTable::IsEmpty() const {
  return field_presence_.IsEmpty();
}

void SerializableTable::Encode(::fidl::Encoder* _encoder, size_t _offset,
                               std::optional<::fidl::HandleInformation> maybe_handle_info) {
  size_t max_ordinal = MaxOrdinal();
  ::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
  if (max_ordinal == 0) return;
  [[maybe_unused]] size_t base = _encoder->Alloc(max_ordinal * sizeof(fidl_envelope_t));
}

void SerializableTable::Decode(::fidl::Decoder* _decoder, SerializableTable* _value, size_t _offset) {
  fidl_vector_t* encoded = _decoder->GetPtr<fidl_vector_t>(_offset);
  [[maybe_unused]] size_t base;
  [[maybe_unused]] size_t count;
  if (!encoded->data) {
    goto clear_all;
  }

  base = _decoder->GetOffset(encoded->data);
  count = encoded->count;

  return;

  // Clear unset values.
clear_all:
  return;
}

zx_status_t SerializableTable::Clone(SerializableTable* result) const {
  return ZX_OK;
}

extern "C" const fidl_type_t test_serializable_SerializableUnionTable;
const fidl_type_t* SerializableUnion::FidlType = &test_serializable_SerializableUnionTable;

SerializableUnion::SerializableUnion() {}

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

SerializableUnion::SerializableUnion(SerializableUnion&& other) : tag_(other.tag_) {
  switch (tag_) {
    case ::test::serializable::SerializableUnion::Tag::kUnused:
      unused_ = std::move(other.unused_);
      break;
    case static_cast<fidl_xunion_tag_t>(::test::serializable::SerializableUnion::Tag::Invalid):
      break;
  }
}

SerializableUnion& SerializableUnion::operator=(SerializableUnion&& other) {
  if (this != &other) {
    Destroy();
    tag_ = other.tag_;
    switch (tag_) {
      case ::test::serializable::SerializableUnion::Tag::kUnused:
        unused_ = std::move(other.unused_);
        break;
      case static_cast<fidl_xunion_tag_t>(::test::serializable::SerializableUnion::Tag::Invalid):
        break;
    }
  }
  return *this;
}

SerializableUnion SerializableUnion::WithUnused(bool&& val) {
  SerializableUnion result;
  result.set_unused(std::move(val));
  return result;
}

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

  switch (Which()) {
    case ::test::serializable::SerializableUnion::Tag::kUnused: {
      if (::fidl::EncodingInlineSize<bool>(encoder) <= FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
        ::fidl::Encode(encoder, &unused_, offset + offsetof(fidl_union_t, envelope));

        fidl_union_t* xunion = encoder->GetPtr<fidl_union_t>(offset);
        xunion->tag = tag_;
        xunion->envelope.num_handles = static_cast<uint16_t>(encoder->CurrentHandleCount() - handles_before);
        xunion->envelope.flags = FIDL_ENVELOPE_FLAGS_INLINING_MASK;
        break;
      }

      ::fidl::Encode(
          encoder,
          &unused_,
          encoder->Alloc(::fidl::EncodingInlineSize<bool, ::fidl::Encoder>(encoder)));

      fidl_union_t* xunion = encoder->GetPtr<fidl_union_t>(offset);
      xunion->tag = tag_;
      xunion->envelope.num_bytes = static_cast<uint32_t>(encoder->CurrentLength() - length_before);
      xunion->envelope.num_handles = static_cast<uint16_t>(encoder->CurrentHandleCount() - handles_before);
      xunion->envelope.flags = 0;
      break;
    }
    default:
      break;
  }
}

void SerializableUnion::Decode(::fidl::Decoder* _decoder, SerializableUnion* value, size_t offset) {
  fidl_union_t* xunion = _decoder->GetPtr<fidl_union_t>(offset);

  if (xunion->envelope.num_bytes == 0 &&
      xunion->envelope.num_handles == 0 &&
      xunion->envelope.flags == 0) {
    value->EnsureStorageInitialized(static_cast<fidl_xunion_tag_t>(::test::serializable::SerializableUnion::Tag::Invalid));
    return;
  }

  value->EnsureStorageInitialized(xunion->tag);

  size_t value_offset = _decoder->EnvelopeValueOffset(&xunion->envelope);

  switch (value->tag_) {
    case ::test::serializable::SerializableUnion::Tag::kUnused: {
      ::fidl::Decode(_decoder, &value->unused_, value_offset);
      break;
    }
    default: {
      break;
    }
  }
}

zx_status_t SerializableUnion::Clone(SerializableUnion* result) const {
  result->Destroy();
  result->tag_ = tag_;
  switch (tag_) {
    case ::test::serializable::SerializableUnion::Tag::Invalid:
      return ZX_OK;
    case ::test::serializable::SerializableUnion::Tag::kUnused:
      return ::fidl::Clone(unused_, &result->unused_);
    default:
      return ZX_OK;
  }
}

SerializableUnion& SerializableUnion::set_unused(bool value) {
  EnsureStorageInitialized(::test::serializable::SerializableUnion::Tag::kUnused);
  unused_ = std::move(value);
  return *this;
}

void SerializableUnion::Destroy() {
  switch (tag_) {
    case ::test::serializable::SerializableUnion::Tag::kUnused:
      break;

    default:
      break;
  }
  tag_ = static_cast<fidl_xunion_tag_t>(::test::serializable::SerializableUnion::Tag::Invalid);
}

void SerializableUnion::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
  if (tag_ != tag) {
    Destroy();
    tag_ = tag;
    switch (tag_) {
      case static_cast<fidl_xunion_tag_t>(::test::serializable::SerializableUnion::Tag::Invalid):
        break;
      case ::test::serializable::SerializableUnion::Tag::kUnused:
        new (&unused_) bool();
        break;
      default:
        break;
    }
  }
}

//
// Proxies and stubs definitions
//
}  // namespace serializable
}  // namespace test