tools/fidl/fidlgen_hlcpp/goldens/doc_comments.cc.golden - fuchsia - Git at Google

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

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

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

 //
 // Domain objects definitions
 //
 namespace test {
 namespace doccomments {
 extern "C" const fidl_type_t test_doccomments_TableTable;
 const fidl_type_t* Table::FidlType = &test_doccomments_TableTable;

 Table::Table() {}

 Table::Table(Table&& other) {
   field_presence_ = other.field_presence_;
   if (field_presence_.IsSet<0>()) {
     Construct(&Field_value_.value, std::move(other.Field_value_.value));
   }
 }

 Table::~Table() {
   if (field_presence_.IsSet<0>()) {
     Destruct(&Field_value_.value);
   }
 }

 Table& Table::operator=(Table&& other) {
   if (other.field_presence_.IsSet<0>()) {
     if (field_presence_.IsSet<0>()) {
       Field_value_.value = std::move(other.Field_value_.value);
     } else {
       field_presence_.Set<0>();
       Construct(&Field_value_.value, std::move(other.Field_value_.value));
     }
   } else if (field_presence_.IsSet<0>()) {
     field_presence_.Clear<0>();
     Destruct(&Field_value_.value);
   }
   return *this;
 }

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

 void Table::Encode(::fidl::Encoder* _encoder, size_t _offset,
                    cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
   size_t max_ordinal = MaxOrdinal();
   ::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
   if (max_ordinal == 0) return;
   __attribute__((__unused__)) size_t base = _encoder->Alloc(max_ordinal * sizeof(fidl_envelope_v2_t));
   if (field_presence_.IsSet<0>()) {
     const size_t length_before = _encoder->CurrentLength();
     const size_t handles_before = _encoder->CurrentHandleCount();

     size_t envelope_base = base + (1 - 1) * sizeof(fidl_envelope_v2_t);

     if (::fidl::EncodingInlineSize<int32_t>(_encoder) <= FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
       ::fidl::Encode(_encoder, &Field_value_.value, envelope_base);

       fidl_envelope_v2_t* envelope = _encoder->GetPtr<fidl_envelope_v2_t>(envelope_base);
       envelope->num_handles = static_cast<uint16_t>(_encoder->CurrentHandleCount() - handles_before);
       envelope->flags = FIDL_ENVELOPE_FLAGS_INLINING_MASK;
     } else {
       ::fidl::Encode(
           _encoder,
           &Field_value_.value,
           _encoder->Alloc(::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(_encoder)));

       fidl_envelope_v2_t* envelope = _encoder->GetPtr<fidl_envelope_v2_t>(envelope_base);
       envelope->num_bytes = static_cast<uint32_t>(_encoder->CurrentLength() - length_before);
       envelope->num_handles = static_cast<uint16_t>(_encoder->CurrentHandleCount() - handles_before);
       envelope->flags = 0;
     }
   }
 }

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

   base = _decoder->GetOffset(encoded->data);
   count = encoded->count;
   if (count >= 1) {
     size_t envelope_base = base + (1 - 1) * sizeof(fidl_envelope_v2_t);
     fidl_envelope_v2_t* envelope = _decoder->GetPtr<fidl_envelope_v2_t>(envelope_base);
     if (*reinterpret_cast<const void* const*>(envelope) != nullptr) {
       ::fidl::Decode(_decoder, _value->mutable_Field(),
                      _decoder->EnvelopeValueOffset(envelope));
     } else {
       _value->clear_Field();
     }
   } else {
     goto done_1;
   }

   return;

   // Clear unset values.
 clear_all:
 done_1:
   _value->clear_Field();
   return;
 }

 zx_status_t Table::Clone(Table* result) const {
   if (field_presence_.IsSet<0>()) {
     zx_status_t _status = ::fidl::Clone(Field_value_.value, result->mutable_Field());
     if (_status != ZX_OK)
       return _status;
   } else {
     result->clear_Field();
   }
   return ZX_OK;
 }

 extern "C" const fidl_type_t test_doccomments_StructTable;
 const fidl_type_t* Struct::FidlType = &test_doccomments_StructTable;

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

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

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

 extern "C" const fidl_type_t test_doccomments_StrictUnionTable;
 const fidl_type_t* StrictUnion::FidlType = &test_doccomments_StrictUnionTable;

 StrictUnion::StrictUnion() {}

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

 StrictUnion::StrictUnion(StrictUnion&& other) : tag_(other.tag_) {
   switch (tag_) {
     case ::test::doccomments::StrictUnion::Tag::kField:
       Field_ = std::move(other.Field_);
       break;
     case static_cast<fidl_xunion_tag_t>(::test::doccomments::StrictUnion::Tag::Invalid):
       break;
   }
 }

 StrictUnion& StrictUnion::operator=(StrictUnion&& other) {
   if (this != &other) {
     Destroy();
     tag_ = other.tag_;
     switch (tag_) {
       case ::test::doccomments::StrictUnion::Tag::kField:
         Field_ = std::move(other.Field_);
         break;
       case static_cast<fidl_xunion_tag_t>(::test::doccomments::StrictUnion::Tag::Invalid):
         break;
     }
   }
   return *this;
 }

 StrictUnion StrictUnion::WithField(int32_t&& val) {
   StrictUnion result;
   result.set_Field(std::move(val));
   return result;
 }

 void StrictUnion::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();

   switch (Which()) {
     case ::test::doccomments::StrictUnion::Tag::kField: {
       if (::fidl::EncodingInlineSize<int32_t>(encoder) <= FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
         ::fidl::Encode(encoder, &Field_, offset + offsetof(fidl_xunion_v2_t, envelope));

         fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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,
           &Field_,
           encoder->Alloc(::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder)));

       fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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 StrictUnion::Decode(::fidl::Decoder* _decoder, StrictUnion* value, size_t offset) {
   fidl_xunion_v2_t* xunion = _decoder->GetPtr<fidl_xunion_v2_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::doccomments::StrictUnion::Tag::Invalid));
     return;
   }

   value->EnsureStorageInitialized(xunion->tag);

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

   switch (value->tag_) {
     case ::test::doccomments::StrictUnion::Tag::kField: {
       ::fidl::Decode(_decoder, &value->Field_, value_offset);
       break;
     }
     default: {
       break;
     }
   }
 }

 zx_status_t StrictUnion::Clone(StrictUnion* result) const {
   result->Destroy();
   result->tag_ = tag_;
   switch (tag_) {
     case ::test::doccomments::StrictUnion::Tag::Invalid:
       return ZX_OK;
     case ::test::doccomments::StrictUnion::Tag::kField:
       return ::fidl::Clone(Field_, &result->Field_);
     default:
       return ZX_OK;
   }
 }

 StrictUnion& StrictUnion::set_Field(int32_t value) {
   EnsureStorageInitialized(::test::doccomments::StrictUnion::Tag::kField);
   Field_ = std::move(value);
   return *this;
 }

 void StrictUnion::Destroy() {
   switch (tag_) {
     case ::test::doccomments::StrictUnion::Tag::kField:
       break;

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

 void StrictUnion::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
   if (tag_ != tag) {
     Destroy();
     tag_ = tag;
     switch (tag_) {
       case static_cast<fidl_xunion_tag_t>(::test::doccomments::StrictUnion::Tag::Invalid):
         break;
       case ::test::doccomments::StrictUnion::Tag::kField:
         new (&Field_) int32_t();
         break;
       default:
         break;
     }
   }
 }

 #if (__cplusplus < 201703)
 constexpr const ::test::doccomments::MyFlexibleEnum MyFlexibleEnum::FOO = ::test::doccomments::MyFlexibleEnum(1u);
 constexpr const ::test::doccomments::MyFlexibleEnum MyFlexibleEnum::BAR = ::test::doccomments::MyFlexibleEnum(2u);
 #endif  // (__cplusplus < 201703)

 #if (__cplusplus < 201703)
 constexpr const ::test::doccomments::MyFlexibleBits MyFlexibleBits::MY_FIRST_BIT = ::test::doccomments::MyFlexibleBits(1u);
 constexpr const ::test::doccomments::MyFlexibleBits MyFlexibleBits::MY_OTHER_BIT = ::test::doccomments::MyFlexibleBits(2u);
 constexpr const ::test::doccomments::MyFlexibleBits MyFlexibleBits::kMask = ::test::doccomments::MyFlexibleBits(3u);

 #endif  // (__cplusplus < 201703)

 extern "C" const fidl_type_t test_doccomments_FlexibleUnionTable;
 const fidl_type_t* FlexibleUnion::FidlType = &test_doccomments_FlexibleUnionTable;

 FlexibleUnion::FlexibleUnion() {}

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

 FlexibleUnion::FlexibleUnion(FlexibleUnion&& other) : tag_(other.tag_) {
   switch (tag_) {
     case ::test::doccomments::FlexibleUnion::Tag::kField:
       Field_ = std::move(other.Field_);
       break;
     case static_cast<fidl_xunion_tag_t>(::test::doccomments::FlexibleUnion::Tag::Invalid):
       break;
     default:
       new (&unknown_data_) decltype(unknown_data_);
       unknown_data_ = std::move(other.unknown_data_);
       break;
   }
 }

 FlexibleUnion& FlexibleUnion::operator=(FlexibleUnion&& other) {
   if (this != &other) {
     Destroy();
     tag_ = other.tag_;
     switch (tag_) {
       case ::test::doccomments::FlexibleUnion::Tag::kField:
         Field_ = std::move(other.Field_);
         break;
       case static_cast<fidl_xunion_tag_t>(::test::doccomments::FlexibleUnion::Tag::Invalid):
         break;
       default:
         new (&unknown_data_) decltype(unknown_data_);
         unknown_data_ = std::move(other.unknown_data_);
         break;
     }
   }
   return *this;
 }

 FlexibleUnion FlexibleUnion::WithField(int32_t&& val) {
   FlexibleUnion result;
   result.set_Field(std::move(val));
   return result;
 }

 void FlexibleUnion::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();

   switch (Which()) {
     case ::test::doccomments::FlexibleUnion::Tag::kField: {
       if (::fidl::EncodingInlineSize<int32_t>(encoder) <= FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
         ::fidl::Encode(encoder, &Field_, offset + offsetof(fidl_xunion_v2_t, envelope));

         fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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,
           &Field_,
           encoder->Alloc(::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder)));

       fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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;
     }
     case ::test::doccomments::FlexibleUnion::Tag::kUnknown: {
       ::fidl::EncodeUnknownBytes(encoder, &unknown_data_, offset + offsetof(fidl_xunion_t, envelope));
       *encoder->GetPtr<uint64_t>(offset) = tag_;
       break;
     }
     default:
       break;
   }
 }

 void FlexibleUnion::Decode(::fidl::Decoder* _decoder, FlexibleUnion* value, size_t offset) {
   fidl_xunion_v2_t* xunion = _decoder->GetPtr<fidl_xunion_v2_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::doccomments::FlexibleUnion::Tag::Invalid));
     return;
   }

   value->EnsureStorageInitialized(xunion->tag);

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

   switch (value->tag_) {
     case ::test::doccomments::FlexibleUnion::Tag::kField: {
       ::fidl::Decode(_decoder, &value->Field_, value_offset);
       break;
     }
     default: {
       auto unknown_info = _decoder->EnvelopeUnknownDataInfo(&xunion->envelope);
       value->unknown_data_.resize(unknown_info.num_bytes);
       ::fidl::DecodeUnknownBytesContents(_decoder, &value->unknown_data_, unknown_info.value_offset);
       break;
     }
   }
 }

 zx_status_t FlexibleUnion::Clone(FlexibleUnion* result) const {
   result->Destroy();
   result->tag_ = tag_;
   switch (tag_) {
     case ::test::doccomments::FlexibleUnion::Tag::Invalid:
       return ZX_OK;
     case ::test::doccomments::FlexibleUnion::Tag::kField:
       return ::fidl::Clone(Field_, &result->Field_);
     default:
       new (&result->unknown_data_) decltype(unknown_data_);
       return ::fidl::Clone(unknown_data_, &result->unknown_data_);
       return ZX_OK;
   }
 }

 FlexibleUnion& FlexibleUnion::set_Field(int32_t value) {
   EnsureStorageInitialized(::test::doccomments::FlexibleUnion::Tag::kField);
   Field_ = std::move(value);
   return *this;
 }
 FlexibleUnion& FlexibleUnion::SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes) {
   EnsureStorageInitialized(ordinal);
   unknown_data_ = std::move(bytes);
   return *this;
 }

 void FlexibleUnion::Destroy() {
   switch (tag_) {
     case ::test::doccomments::FlexibleUnion::Tag::kField:
       break;

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

 void FlexibleUnion::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
   if (tag_ != tag) {
     Destroy();
     tag_ = tag;
     switch (tag_) {
       case static_cast<fidl_xunion_tag_t>(::test::doccomments::FlexibleUnion::Tag::Invalid):
         break;
       case ::test::doccomments::FlexibleUnion::Tag::kField:
         new (&Field_) int32_t();
         break;
       default:
         new (&unknown_data_) decltype(unknown_data_);
         break;
     }
   }
 }

 //
 // Proxies and stubs definitions
 //
 #ifdef __Fuchsia__

 Interface::~Interface() = default;

 const fidl_type_t* ::test::doccomments::Interface_RequestDecoder::GetType(uint64_t ordinal, bool* out_needs_response) {
   *out_needs_response = false;
   switch (ordinal) {
     case ::test::doccomments::internal::kInterface_Method_Ordinal:
       return nullptr;
       ;
     default:
       return nullptr;
   }
 }

 const fidl_type_t* Interface_ResponseDecoder::GetType(uint64_t ordinal) {
   switch (ordinal) {
     case ::test::doccomments::internal::kInterface_OnEvent_Ordinal:
       return nullptr;
       ;
     default:
       return nullptr;
   }
 }

 Interface_EventSender::~Interface_EventSender() = default;

 Interface_Sync::~Interface_Sync() = default;

 Interface_Proxy::Interface_Proxy(::fidl::internal::ProxyController* controller)
     : controller_(controller) {
   (void)controller_;
 }

 Interface_Proxy::~Interface_Proxy() = default;

 zx_status_t Interface_Proxy::Dispatch_(::fidl::HLCPPIncomingMessage message) {
   zx_status_t status = ZX_OK;
   switch (message.ordinal()) {
     case ::test::doccomments::internal::kInterface_OnEvent_Ordinal: {
       if (!OnEvent) {
         status = ZX_OK;
         break;
       }
       OnEvent();
       break;
     }
     default: {
       status = ZX_ERR_NOT_SUPPORTED;
       break;
     }
   }
   return status;
 }

 void Interface_Proxy::Method() {
   ::fidl::MessageEncoder _encoder(::test::doccomments::internal::kInterface_Method_Ordinal, ::test::doccomments::internal::kInterface_Method_DynamicFlags);
   const fidl_type_t* req_type = nullptr;
   controller_->Send(req_type, ::test::doccomments::Interface_RequestEncoder::Method(&_encoder), nullptr);
 }

 Interface_Stub::Interface_Stub(::test::doccomments::Interface_Stub::Interface_clazz* impl) : impl_(impl) {
   (void)impl_;
 }

 Interface_Stub::~Interface_Stub() = default;

 namespace {

 }  // namespace

 zx_status_t Interface_Stub::Dispatch_(
     ::fidl::HLCPPIncomingMessage message,
     ::fidl::internal::PendingResponse response) {
   bool needs_response;
   const fidl_type_t* request_type = ::test::doccomments::Interface_RequestDecoder::GetType(message.ordinal(), &needs_response);
   if (!message.has_only_header()) {
     if (request_type == nullptr) {
       return ZX_ERR_NOT_SUPPORTED;
     }
     const char* error_msg = nullptr;
     zx_status_t status = message.Decode(request_type, &error_msg);
     if (status != ZX_OK) {
       FIDL_REPORT_DECODING_ERROR(message, request_type, error_msg);
       return status;
     }
   }

   if (response.needs_response() != needs_response) {
     if (needs_response) {
       FIDL_REPORT_DECODING_ERROR(message, request_type, "Message needing a response with no txid");
     } else {
       FIDL_REPORT_DECODING_ERROR(message, request_type, "Message not needing a response with a txid");
     }
     return ZX_ERR_INVALID_ARGS;
   }

   uint64_t ordinal = message.ordinal();
   switch (ordinal) {
     case ::test::doccomments::internal::kInterface_Method_Ordinal: {
       impl_->Method();
       break;
     }
     default: {
       return ZX_ERR_NOT_SUPPORTED;
     }
   }
   return ZX_OK;
 }
 void Interface_Stub::OnEvent() {
   ::fidl::MessageEncoder _encoder(::test::doccomments::internal::kInterface_OnEvent_Ordinal, ::test::doccomments::internal::kInterface_OnEvent_DynamicFlags);
   const fidl_type_t* resp_type = nullptr;
   sender_()->Send(resp_type, ::test::doccomments::Interface_ResponseEncoder::OnEvent(&_encoder));
 }

 Interface_SyncProxy::Interface_SyncProxy(::zx::channel channel)
     : proxy_(::std::move(channel)) {}

 Interface_SyncProxy::~Interface_SyncProxy() = default;

 zx_status_t Interface_SyncProxy::Method() {
   ::fidl::MessageEncoder _encoder(::test::doccomments::internal::kInterface_Method_Ordinal, ::test::doccomments::internal::kInterface_Method_DynamicFlags);
   const fidl_type_t* req_type = nullptr;
   return proxy_.Send(req_type, ::test::doccomments::Interface_RequestEncoder::Method(&_encoder));
 }
 #endif  // __Fuchsia__

 }  // namespace doccomments
 }  // namespace test
	// WARNING: This file is machine generated by fidlgen.

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

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

	//
	// Domain objects definitions
	//
	namespace test {
	namespace doccomments {
	extern "C" const fidl_type_t test_doccomments_TableTable;
	const fidl_type_t* Table::FidlType = &test_doccomments_TableTable;

	Table::Table() {}

	Table::Table(Table&& other) {
	field_presence_ = other.field_presence_;
	if (field_presence_.IsSet<0>()) {
	Construct(&Field_value_.value, std::move(other.Field_value_.value));
	}
	}

	Table::~Table() {
	if (field_presence_.IsSet<0>()) {
	Destruct(&Field_value_.value);
	}
	}

	Table& Table::operator=(Table&& other) {
	if (other.field_presence_.IsSet<0>()) {
	if (field_presence_.IsSet<0>()) {
	Field_value_.value = std::move(other.Field_value_.value);
	} else {
	field_presence_.Set<0>();
	Construct(&Field_value_.value, std::move(other.Field_value_.value));
	}
	} else if (field_presence_.IsSet<0>()) {
	field_presence_.Clear<0>();
	Destruct(&Field_value_.value);
	}
	return *this;
	}

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

	void Table::Encode(::fidl::Encoder* _encoder, size_t _offset,
	cpp17::optional<::fidl::HandleInformation> maybe_handle_info) {
	size_t max_ordinal = MaxOrdinal();
	::fidl::EncodeVectorPointer(_encoder, max_ordinal, _offset);
	if (max_ordinal == 0) return;
	__attribute__((__unused__)) size_t base = _encoder->Alloc(max_ordinal * sizeof(fidl_envelope_v2_t));
	if (field_presence_.IsSet<0>()) {
	const size_t length_before = _encoder->CurrentLength();
	const size_t handles_before = _encoder->CurrentHandleCount();

	size_t envelope_base = base + (1 - 1) * sizeof(fidl_envelope_v2_t);

	if (::fidl::EncodingInlineSize<int32_t>(_encoder) <= FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
	::fidl::Encode(_encoder, &Field_value_.value, envelope_base);

	fidl_envelope_v2_t* envelope = _encoder->GetPtr<fidl_envelope_v2_t>(envelope_base);
	envelope->num_handles = static_cast<uint16_t>(_encoder->CurrentHandleCount() - handles_before);
	envelope->flags = FIDL_ENVELOPE_FLAGS_INLINING_MASK;
	} else {
	::fidl::Encode(
	_encoder,
	&Field_value_.value,
	_encoder->Alloc(::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(_encoder)));

	fidl_envelope_v2_t* envelope = _encoder->GetPtr<fidl_envelope_v2_t>(envelope_base);
	envelope->num_bytes = static_cast<uint32_t>(_encoder->CurrentLength() - length_before);
	envelope->num_handles = static_cast<uint16_t>(_encoder->CurrentHandleCount() - handles_before);
	envelope->flags = 0;
	}
	}
	}

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

	base = _decoder->GetOffset(encoded->data);
	count = encoded->count;
	if (count >= 1) {
	size_t envelope_base = base + (1 - 1) * sizeof(fidl_envelope_v2_t);
	fidl_envelope_v2_t* envelope = _decoder->GetPtr<fidl_envelope_v2_t>(envelope_base);
	if (reinterpret_cast<const void const*>(envelope) != nullptr) {
	::fidl::Decode(_decoder, _value->mutable_Field(),
	_decoder->EnvelopeValueOffset(envelope));
	} else {
	_value->clear_Field();
	}
	} else {
	goto done_1;
	}

	return;

	// Clear unset values.
	clear_all:
	done_1:
	_value->clear_Field();
	return;
	}

	zx_status_t Table::Clone(Table* result) const {
	if (field_presence_.IsSet<0>()) {
	zx_status_t _status = ::fidl::Clone(Field_value_.value, result->mutable_Field());
	if (_status != ZX_OK)
	return _status;
	} else {
	result->clear_Field();
	}
	return ZX_OK;
	}

	extern "C" const fidl_type_t test_doccomments_StructTable;
	const fidl_type_t* Struct::FidlType = &test_doccomments_StructTable;

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

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

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

	extern "C" const fidl_type_t test_doccomments_StrictUnionTable;
	const fidl_type_t* StrictUnion::FidlType = &test_doccomments_StrictUnionTable;

	StrictUnion::StrictUnion() {}

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

	StrictUnion::StrictUnion(StrictUnion&& other) : tag_(other.tag_) {
	switch (tag_) {
	case ::test::doccomments::StrictUnion::Tag::kField:
	Field_ = std::move(other.Field_);
	break;
	case static_cast<fidl_xunion_tag_t>(::test::doccomments::StrictUnion::Tag::Invalid):
	break;
	}
	}

	StrictUnion& StrictUnion::operator=(StrictUnion&& other) {
	if (this != &other) {
	Destroy();
	tag_ = other.tag_;
	switch (tag_) {
	case ::test::doccomments::StrictUnion::Tag::kField:
	Field_ = std::move(other.Field_);
	break;
	case static_cast<fidl_xunion_tag_t>(::test::doccomments::StrictUnion::Tag::Invalid):
	break;
	}
	}
	return *this;
	}

	StrictUnion StrictUnion::WithField(int32_t&& val) {
	StrictUnion result;
	result.set_Field(std::move(val));
	return result;
	}

	void StrictUnion::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();

	switch (Which()) {
	case ::test::doccomments::StrictUnion::Tag::kField: {
	if (::fidl::EncodingInlineSize<int32_t>(encoder) <= FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
	::fidl::Encode(encoder, &Field_, offset + offsetof(fidl_xunion_v2_t, envelope));

	fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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,
	&Field_,
	encoder->Alloc(::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder)));

	fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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 StrictUnion::Decode(::fidl::Decoder* _decoder, StrictUnion* value, size_t offset) {
	fidl_xunion_v2_t* xunion = _decoder->GetPtr<fidl_xunion_v2_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::doccomments::StrictUnion::Tag::Invalid));
	return;
	}

	value->EnsureStorageInitialized(xunion->tag);

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

	switch (value->tag_) {
	case ::test::doccomments::StrictUnion::Tag::kField: {
	::fidl::Decode(_decoder, &value->Field_, value_offset);
	break;
	}
	default: {
	break;
	}
	}
	}

	zx_status_t StrictUnion::Clone(StrictUnion* result) const {
	result->Destroy();
	result->tag_ = tag_;
	switch (tag_) {
	case ::test::doccomments::StrictUnion::Tag::Invalid:
	return ZX_OK;
	case ::test::doccomments::StrictUnion::Tag::kField:
	return ::fidl::Clone(Field_, &result->Field_);
	default:
	return ZX_OK;
	}
	}

	StrictUnion& StrictUnion::set_Field(int32_t value) {
	EnsureStorageInitialized(::test::doccomments::StrictUnion::Tag::kField);
	Field_ = std::move(value);
	return *this;
	}

	void StrictUnion::Destroy() {
	switch (tag_) {
	case ::test::doccomments::StrictUnion::Tag::kField:
	break;

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

	void StrictUnion::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
	if (tag_ != tag) {
	Destroy();
	tag_ = tag;
	switch (tag_) {
	case static_cast<fidl_xunion_tag_t>(::test::doccomments::StrictUnion::Tag::Invalid):
	break;
	case ::test::doccomments::StrictUnion::Tag::kField:
	new (&Field_) int32_t();
	break;
	default:
	break;
	}
	}
	}

	#if (__cplusplus < 201703)
	constexpr const ::test::doccomments::MyFlexibleEnum MyFlexibleEnum::FOO = ::test::doccomments::MyFlexibleEnum(1u);
	constexpr const ::test::doccomments::MyFlexibleEnum MyFlexibleEnum::BAR = ::test::doccomments::MyFlexibleEnum(2u);
	#endif // (__cplusplus < 201703)

	#if (__cplusplus < 201703)
	constexpr const ::test::doccomments::MyFlexibleBits MyFlexibleBits::MY_FIRST_BIT = ::test::doccomments::MyFlexibleBits(1u);
	constexpr const ::test::doccomments::MyFlexibleBits MyFlexibleBits::MY_OTHER_BIT = ::test::doccomments::MyFlexibleBits(2u);
	constexpr const ::test::doccomments::MyFlexibleBits MyFlexibleBits::kMask = ::test::doccomments::MyFlexibleBits(3u);

	#endif // (__cplusplus < 201703)

	extern "C" const fidl_type_t test_doccomments_FlexibleUnionTable;
	const fidl_type_t* FlexibleUnion::FidlType = &test_doccomments_FlexibleUnionTable;

	FlexibleUnion::FlexibleUnion() {}

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

	FlexibleUnion::FlexibleUnion(FlexibleUnion&& other) : tag_(other.tag_) {
	switch (tag_) {
	case ::test::doccomments::FlexibleUnion::Tag::kField:
	Field_ = std::move(other.Field_);
	break;
	case static_cast<fidl_xunion_tag_t>(::test::doccomments::FlexibleUnion::Tag::Invalid):
	break;
	default:
	new (&unknown_data_) decltype(unknown_data_);
	unknown_data_ = std::move(other.unknown_data_);
	break;
	}
	}

	FlexibleUnion& FlexibleUnion::operator=(FlexibleUnion&& other) {
	if (this != &other) {
	Destroy();
	tag_ = other.tag_;
	switch (tag_) {
	case ::test::doccomments::FlexibleUnion::Tag::kField:
	Field_ = std::move(other.Field_);
	break;
	case static_cast<fidl_xunion_tag_t>(::test::doccomments::FlexibleUnion::Tag::Invalid):
	break;
	default:
	new (&unknown_data_) decltype(unknown_data_);
	unknown_data_ = std::move(other.unknown_data_);
	break;
	}
	}
	return *this;
	}

	FlexibleUnion FlexibleUnion::WithField(int32_t&& val) {
	FlexibleUnion result;
	result.set_Field(std::move(val));
	return result;
	}

	void FlexibleUnion::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();

	switch (Which()) {
	case ::test::doccomments::FlexibleUnion::Tag::kField: {
	if (::fidl::EncodingInlineSize<int32_t>(encoder) <= FIDL_ENVELOPE_INLINING_SIZE_THRESHOLD) {
	::fidl::Encode(encoder, &Field_, offset + offsetof(fidl_xunion_v2_t, envelope));

	fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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,
	&Field_,
	encoder->Alloc(::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder)));

	fidl_xunion_v2_t* xunion = encoder->GetPtr<fidl_xunion_v2_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;
	}
	case ::test::doccomments::FlexibleUnion::Tag::kUnknown: {
	::fidl::EncodeUnknownBytes(encoder, &unknown_data_, offset + offsetof(fidl_xunion_t, envelope));
	*encoder->GetPtr<uint64_t>(offset) = tag_;
	break;
	}
	default:
	break;
	}
	}

	void FlexibleUnion::Decode(::fidl::Decoder* _decoder, FlexibleUnion* value, size_t offset) {
	fidl_xunion_v2_t* xunion = _decoder->GetPtr<fidl_xunion_v2_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::doccomments::FlexibleUnion::Tag::Invalid));
	return;
	}

	value->EnsureStorageInitialized(xunion->tag);

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

	switch (value->tag_) {
	case ::test::doccomments::FlexibleUnion::Tag::kField: {
	::fidl::Decode(_decoder, &value->Field_, value_offset);
	break;
	}
	default: {
	auto unknown_info = _decoder->EnvelopeUnknownDataInfo(&xunion->envelope);
	value->unknown_data_.resize(unknown_info.num_bytes);
	::fidl::DecodeUnknownBytesContents(_decoder, &value->unknown_data_, unknown_info.value_offset);
	break;
	}
	}
	}

	zx_status_t FlexibleUnion::Clone(FlexibleUnion* result) const {
	result->Destroy();
	result->tag_ = tag_;
	switch (tag_) {
	case ::test::doccomments::FlexibleUnion::Tag::Invalid:
	return ZX_OK;
	case ::test::doccomments::FlexibleUnion::Tag::kField:
	return ::fidl::Clone(Field_, &result->Field_);
	default:
	new (&result->unknown_data_) decltype(unknown_data_);
	return ::fidl::Clone(unknown_data_, &result->unknown_data_);
	return ZX_OK;
	}
	}

	FlexibleUnion& FlexibleUnion::set_Field(int32_t value) {
	EnsureStorageInitialized(::test::doccomments::FlexibleUnion::Tag::kField);
	Field_ = std::move(value);
	return *this;
	}
	FlexibleUnion& FlexibleUnion::SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes) {
	EnsureStorageInitialized(ordinal);
	unknown_data_ = std::move(bytes);
	return *this;
	}

	void FlexibleUnion::Destroy() {
	switch (tag_) {
	case ::test::doccomments::FlexibleUnion::Tag::kField:
	break;

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

	void FlexibleUnion::EnsureStorageInitialized(::fidl_xunion_tag_t tag) {
	if (tag_ != tag) {
	Destroy();
	tag_ = tag;
	switch (tag_) {
	case static_cast<fidl_xunion_tag_t>(::test::doccomments::FlexibleUnion::Tag::Invalid):
	break;
	case ::test::doccomments::FlexibleUnion::Tag::kField:
	new (&Field_) int32_t();
	break;
	default:
	new (&unknown_data_) decltype(unknown_data_);
	break;
	}
	}
	}

	//
	// Proxies and stubs definitions
	//
	#ifdef __Fuchsia__

	Interface::~Interface() = default;

	const fidl_type_t* ::test::doccomments::Interface_RequestDecoder::GetType(uint64_t ordinal, bool* out_needs_response) {
	*out_needs_response = false;
	switch (ordinal) {
	case ::test::doccomments::internal::kInterface_Method_Ordinal:
	return nullptr;
	;
	default:
	return nullptr;
	}
	}

	const fidl_type_t* Interface_ResponseDecoder::GetType(uint64_t ordinal) {
	switch (ordinal) {
	case ::test::doccomments::internal::kInterface_OnEvent_Ordinal:
	return nullptr;
	;
	default:
	return nullptr;
	}
	}

	Interface_EventSender::~Interface_EventSender() = default;

	Interface_Sync::~Interface_Sync() = default;

	Interface_Proxy::Interface_Proxy(::fidl::internal::ProxyController* controller)
	: controller_(controller) {
	(void)controller_;
	}

	Interface_Proxy::~Interface_Proxy() = default;

	zx_status_t Interface_Proxy::Dispatch_(::fidl::HLCPPIncomingMessage message) {
	zx_status_t status = ZX_OK;
	switch (message.ordinal()) {
	case ::test::doccomments::internal::kInterface_OnEvent_Ordinal: {
	if (!OnEvent) {
	status = ZX_OK;
	break;
	}
	OnEvent();
	break;
	}
	default: {
	status = ZX_ERR_NOT_SUPPORTED;
	break;
	}
	}
	return status;
	}

	void Interface_Proxy::Method() {
	::fidl::MessageEncoder _encoder(::test::doccomments::internal::kInterface_Method_Ordinal, ::test::doccomments::internal::kInterface_Method_DynamicFlags);
	const fidl_type_t* req_type = nullptr;
	controller_->Send(req_type, ::test::doccomments::Interface_RequestEncoder::Method(&_encoder), nullptr);
	}

	Interface_Stub::Interface_Stub(::test::doccomments::Interface_Stub::Interface_clazz* impl) : impl_(impl) {
	(void)impl_;
	}

	Interface_Stub::~Interface_Stub() = default;

	namespace {

	} // namespace

	zx_status_t Interface_Stub::Dispatch_(
	::fidl::HLCPPIncomingMessage message,
	::fidl::internal::PendingResponse response) {
	bool needs_response;
	const fidl_type_t* request_type = ::test::doccomments::Interface_RequestDecoder::GetType(message.ordinal(), &needs_response);
	if (!message.has_only_header()) {
	if (request_type == nullptr) {
	return ZX_ERR_NOT_SUPPORTED;
	}
	const char* error_msg = nullptr;
	zx_status_t status = message.Decode(request_type, &error_msg);
	if (status != ZX_OK) {
	FIDL_REPORT_DECODING_ERROR(message, request_type, error_msg);
	return status;
	}
	}

	if (response.needs_response() != needs_response) {
	if (needs_response) {
	FIDL_REPORT_DECODING_ERROR(message, request_type, "Message needing a response with no txid");
	} else {
	FIDL_REPORT_DECODING_ERROR(message, request_type, "Message not needing a response with a txid");
	}
	return ZX_ERR_INVALID_ARGS;
	}

	uint64_t ordinal = message.ordinal();
	switch (ordinal) {
	case ::test::doccomments::internal::kInterface_Method_Ordinal: {
	impl_->Method();
	break;
	}
	default: {
	return ZX_ERR_NOT_SUPPORTED;
	}
	}
	return ZX_OK;
	}
	void Interface_Stub::OnEvent() {
	::fidl::MessageEncoder _encoder(::test::doccomments::internal::kInterface_OnEvent_Ordinal, ::test::doccomments::internal::kInterface_OnEvent_DynamicFlags);
	const fidl_type_t* resp_type = nullptr;
	sender_()->Send(resp_type, ::test::doccomments::Interface_ResponseEncoder::OnEvent(&_encoder));
	}

	Interface_SyncProxy::Interface_SyncProxy(::zx::channel channel)
	: proxy_(::std::move(channel)) {}

	Interface_SyncProxy::~Interface_SyncProxy() = default;

	zx_status_t Interface_SyncProxy::Method() {
	::fidl::MessageEncoder _encoder(::test::doccomments::internal::kInterface_Method_Ordinal, ::test::doccomments::internal::kInterface_Method_DynamicFlags);
	const fidl_type_t* req_type = nullptr;
	return proxy_.Send(req_type, ::test::doccomments::Interface_RequestEncoder::Method(&_encoder));
	}
	#endif // __Fuchsia__

	} // namespace doccomments
	} // namespace test