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

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

#include <fidl/test/requestflexibleenvelope/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 requestflexibleenvelope {
extern "C" const fidl_type_t fidl_test_requestflexibleenvelope_StrictFooTable;
const fidl_type_t* StrictFoo::FidlType =
    &fidl_test_requestflexibleenvelope_StrictFooTable;

StrictFoo::StrictFoo() {}

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

StrictFoo::StrictFoo(StrictFoo&& other) : tag_(other.tag_) {
  switch (tag_) {
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS:
      new (&s_)::std::string();
      s_ = std::move(other.s_);
      break;
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI:
      i_ = std::move(other.i_);
      break;
    case static_cast<fidl_xunion_tag_t>(
        ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::Invalid):
      break;
  }
}

StrictFoo& StrictFoo::operator=(StrictFoo&& other) {
  if (this != &other) {
    Destroy();
    tag_ = other.tag_;
    switch (tag_) {
      case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS:
        new (&s_)::std::string();
        s_ = std::move(other.s_);
        break;
      case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI:
        i_ = std::move(other.i_);
        break;
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::Invalid):
        break;
    }
  }
  return *this;
}

StrictFoo StrictFoo::WithS(::std::string&& val) {
  StrictFoo result;
  result.set_s(std::move(val));
  return result;
}
StrictFoo StrictFoo::WithI(int32_t&& val) {
  StrictFoo result;
  result.set_i(std::move(val));
  return result;
}

void StrictFoo::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::requestflexibleenvelope::StrictFoo::Tag::kS: {
      envelope_offset = encoder->Alloc(
          ::fidl::EncodingInlineSize<::std::string, ::fidl::Encoder>(encoder));
      ::fidl::Encode(encoder, &s_, envelope_offset);
      break;
    }
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI: {
      envelope_offset = encoder->Alloc(
          ::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder));
      ::fidl::Encode(encoder, &i_, 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 StrictFoo::Decode(::fidl::Decoder* decoder, StrictFoo* 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::requestflexibleenvelope::StrictFoo::Tag::Invalid));
    return;
  }

  value->EnsureStorageInitialized(xunion->tag);

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

  switch (value->tag_) {
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS:
      new (&value->s_)::std::string();
      ::fidl::Decode(decoder, &value->s_, envelope_offset);
      break;
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI:
      ::fidl::Decode(decoder, &value->i_, envelope_offset);
      break;
    default:
      break;
  }
}

zx_status_t StrictFoo::Clone(StrictFoo* result) const {
  result->Destroy();
  result->tag_ = tag_;
  switch (tag_) {
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::Invalid:
      return ZX_OK;
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS:
      new (&result->s_)::std::string();
      return ::fidl::Clone(s_, &result->s_);
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI:
      return ::fidl::Clone(i_, &result->i_);
    default:
      return ZX_OK;
  }
}

StrictFoo& StrictFoo::set_s(::std::string value) {
  EnsureStorageInitialized(
      ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS);
  s_ = std::move(value);
  return *this;
}

StrictFoo& StrictFoo::set_i(int32_t value) {
  EnsureStorageInitialized(
      ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI);
  i_ = std::move(value);
  return *this;
}

void StrictFoo::Destroy() {
  switch (tag_) {
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS:
      s_.~decltype(s_)();
      break;
    case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI:
      break;

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

void StrictFoo::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
  if (tag_ != tag) {
    Destroy();
    tag_ = tag;
    switch (tag_) {
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::Invalid):
        break;
      case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kS:
        new (&s_)::std::string();
        break;
      case ::fidl::test::requestflexibleenvelope::StrictFoo::Tag::kI:
        new (&i_) int32_t();
        break;
      default:
        break;
    }
  }
}

extern "C" const fidl_type_t fidl_test_requestflexibleenvelope_FlexibleFooTable;
const fidl_type_t* FlexibleFoo::FidlType =
    &fidl_test_requestflexibleenvelope_FlexibleFooTable;

FlexibleFoo::FlexibleFoo() {}

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

FlexibleFoo::FlexibleFoo(FlexibleFoo&& other) : tag_(other.tag_) {
  switch (tag_) {
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS:
      new (&s_)::std::string();
      s_ = std::move(other.s_);
      break;
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI:
      i_ = std::move(other.i_);
      break;
    case static_cast<fidl_xunion_tag_t>(
        ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::Invalid):
      break;
    default:
      new (&unknown_data_) decltype(unknown_data_);
      unknown_data_ = std::move(other.unknown_data_);
      break;
  }
}

FlexibleFoo& FlexibleFoo::operator=(FlexibleFoo&& other) {
  if (this != &other) {
    Destroy();
    tag_ = other.tag_;
    switch (tag_) {
      case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS:
        new (&s_)::std::string();
        s_ = std::move(other.s_);
        break;
      case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI:
        i_ = std::move(other.i_);
        break;
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::Invalid):
        break;
      default:
        new (&unknown_data_) decltype(unknown_data_);
        unknown_data_ = std::move(other.unknown_data_);
        break;
    }
  }
  return *this;
}

FlexibleFoo FlexibleFoo::WithS(::std::string&& val) {
  FlexibleFoo result;
  result.set_s(std::move(val));
  return result;
}
FlexibleFoo FlexibleFoo::WithI(int32_t&& val) {
  FlexibleFoo result;
  result.set_i(std::move(val));
  return result;
}

void FlexibleFoo::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::requestflexibleenvelope::FlexibleFoo::Tag::kS: {
      envelope_offset = encoder->Alloc(
          ::fidl::EncodingInlineSize<::std::string, ::fidl::Encoder>(encoder));
      ::fidl::Encode(encoder, &s_, envelope_offset);
      break;
    }
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI: {
      envelope_offset = encoder->Alloc(
          ::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder));
      ::fidl::Encode(encoder, &i_, envelope_offset);
      break;
    }
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kUnknown:
      envelope_offset = encoder->Alloc(unknown_data_.size());
      ::fidl::EncodeUnknownBytesContents(encoder, &unknown_data_,
                                         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 FlexibleFoo::Decode(::fidl::Decoder* decoder, FlexibleFoo* 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::requestflexibleenvelope::FlexibleFoo::Tag::Invalid));
    return;
  }

  value->EnsureStorageInitialized(xunion->tag);

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

  switch (value->tag_) {
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS:
      new (&value->s_)::std::string();
      ::fidl::Decode(decoder, &value->s_, envelope_offset);
      break;
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI:
      ::fidl::Decode(decoder, &value->i_, envelope_offset);
      break;
    default:

      value->unknown_data_.resize(xunion->envelope.num_bytes);
      ::fidl::DecodeUnknownBytesContents(decoder, &value->unknown_data_,
                                         envelope_offset);
      break;
  }
}

zx_status_t FlexibleFoo::Clone(FlexibleFoo* result) const {
  result->Destroy();
  result->tag_ = tag_;
  switch (tag_) {
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::Invalid:
      return ZX_OK;
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS:
      new (&result->s_)::std::string();
      return ::fidl::Clone(s_, &result->s_);
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI:
      return ::fidl::Clone(i_, &result->i_);
    default:
      new (&result->unknown_data_) decltype(unknown_data_);
      return ::fidl::Clone(unknown_data_, &result->unknown_data_);
      return ZX_OK;
  }
}

FlexibleFoo& FlexibleFoo::set_s(::std::string value) {
  EnsureStorageInitialized(
      ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS);
  s_ = std::move(value);
  return *this;
}

FlexibleFoo& FlexibleFoo::set_i(int32_t value) {
  EnsureStorageInitialized(
      ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI);
  i_ = std::move(value);
  return *this;
}
FlexibleFoo& FlexibleFoo::SetUnknownData(fidl_xunion_tag_t ordinal,
                                         std::vector<uint8_t> bytes) {
  EnsureStorageInitialized(ordinal);
  unknown_data_ = std::move(bytes);
  return *this;
}

void FlexibleFoo::Destroy() {
  switch (tag_) {
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS:
      s_.~decltype(s_)();
      break;
    case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI:
      break;

    case static_cast<fidl_xunion_tag_t>(
        ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::Invalid):
      break;
    default:
      unknown_data_.~decltype(unknown_data_)();
      break;
  }
  tag_ = static_cast<fidl_xunion_tag_t>(
      ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::Invalid);
}

void FlexibleFoo::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
  if (tag_ != tag) {
    Destroy();
    tag_ = tag;
    switch (tag_) {
      case static_cast<fidl_xunion_tag_t>(
          ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::Invalid):
        break;
      case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kS:
        new (&s_)::std::string();
        break;
      case ::fidl::test::requestflexibleenvelope::FlexibleFoo::Tag::kI:
        new (&i_) int32_t();
        break;
      default:
        new (&unknown_data_) decltype(unknown_data_);
        break;
    }
  }
}

}  // namespace requestflexibleenvelope
}  // namespace test
}  // namespace fidl