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

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

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

 #include "lib/fidl/cpp/internal/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 Tag::kS:
       new (&s_)::std::string();
       s_ = std::move(other.s_);
       break;
     case Tag::kI:
       i_ = std::move(other.i_);
       break;
     case static_cast<fidl_xunion_tag_t>(Tag::Invalid):
       break;
   }
 }

 StrictFoo& StrictFoo::operator=(StrictFoo&& other) {
   if (this != &other) {
     Destroy();
     tag_ = other.tag_;
     switch (tag_) {
       case Tag::kS:
         new (&s_)::std::string();
         s_ = std::move(other.s_);
         break;
       case Tag::kI:
         i_ = std::move(other.i_);
         break;
       case static_cast<fidl_xunion_tag_t>(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) {
   const size_t length_before = encoder->CurrentLength();
   const size_t handles_before = encoder->CurrentHandleCount();

   size_t envelope_offset = 0;

   switch (Which()) {
     case Tag::kS: {
       envelope_offset = encoder->Alloc(
           ::fidl::EncodingInlineSize<::std::string, ::fidl::Encoder>(encoder));
       ::fidl::Encode(encoder, &s_, envelope_offset);
       break;
     }
     case 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>(Tag::Invalid));
     return;
   }

   value->EnsureStorageInitialized(xunion->tag);

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

   switch (value->tag_) {
     case Tag::kS:
       new (&value->s_)::std::string();
       ::fidl::Decode(decoder, &value->s_, envelope_offset);
       break;
     case 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 Tag::Invalid:
       return ZX_OK;
     case Tag::kS:
       new (&result->s_)::std::string();
       return ::fidl::Clone(s_, &result->s_);
     case Tag::kI:
       return ::fidl::Clone(i_, &result->i_);
     default:
       return ZX_OK;
   }
 }

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

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

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

     default:
       break;
   }
   tag_ = static_cast<fidl_xunion_tag_t>(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>(Tag::Invalid):
         break;
       case Tag::kS:
         new (&s_)::std::string();
         break;
       case 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 Tag::kS:
       new (&s_)::std::string();
       s_ = std::move(other.s_);
       break;
     case Tag::kI:
       i_ = std::move(other.i_);
       break;
     case static_cast<fidl_xunion_tag_t>(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 Tag::kS:
         new (&s_)::std::string();
         s_ = std::move(other.s_);
         break;
       case Tag::kI:
         i_ = std::move(other.i_);
         break;
       case static_cast<fidl_xunion_tag_t>(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) {
   const size_t length_before = encoder->CurrentLength();
   const size_t handles_before = encoder->CurrentHandleCount();

   size_t envelope_offset = 0;

   switch (Which()) {
     case Tag::kS: {
       envelope_offset = encoder->Alloc(
           ::fidl::EncodingInlineSize<::std::string, ::fidl::Encoder>(encoder));
       ::fidl::Encode(encoder, &s_, envelope_offset);
       break;
     }
     case Tag::kI: {
       envelope_offset = encoder->Alloc(
           ::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder));
       ::fidl::Encode(encoder, &i_, envelope_offset);
       break;
     }
     case 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>(Tag::Invalid));
     return;
   }

   value->EnsureStorageInitialized(xunion->tag);

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

   switch (value->tag_) {
     case Tag::kS:
       new (&value->s_)::std::string();
       ::fidl::Decode(decoder, &value->s_, envelope_offset);
       break;
     case 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 Tag::Invalid:
       return ZX_OK;
     case Tag::kS:
       new (&result->s_)::std::string();
       return ::fidl::Clone(s_, &result->s_);
     case 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(Tag::kS);
   s_ = std::move(value);
   return *this;
 }

 FlexibleFoo& FlexibleFoo::set_i(int32_t value) {
   EnsureStorageInitialized(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 Tag::kS:
       s_.~decltype(s_)();
       break;
     case Tag::kI:
       break;

     case static_cast<fidl_xunion_tag_t>(Tag::Invalid):
       break;
     default:
       unknown_data_.~decltype(unknown_data_)();
       break;
   }
   tag_ = static_cast<fidl_xunion_tag_t>(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>(Tag::Invalid):
         break;
       case Tag::kS:
         new (&s_)::std::string();
         break;
       case Tag::kI:
         new (&i_) int32_t();
         break;
       default:
         new (&unknown_data_) decltype(unknown_data_);
         break;
     }
   }
 }
 }  // namespace requestflexibleenvelope
 }  // namespace test
 }  // namespace fidl

 //
 // Proxies and stubs definitions
 //
 namespace fidl {
 namespace test {
 namespace requestflexibleenvelope {

 #ifdef __Fuchsia__
 namespace {

 extern "C" const fidl_type_t
     fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable;
 extern "C" const fidl_type_t
     fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable;

 extern "C" const fidl_type_t
     fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable;
 extern "C" const fidl_type_t
     fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable;

 }  // namespace

 Protocol::~Protocol() = default;

 const fidl_type_t* Protocol_RequestDecoder::GetType(uint64_t ordinal,
                                                     bool* out_needs_response) {
   switch (ordinal) {
     case internal::kProtocol_RequestStrictResponseFlexible_Ordinal:
       *out_needs_response = true;
       return &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable;
     case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal:
       *out_needs_response = true;
       return &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable;
     default:
       *out_needs_response = false;
       return nullptr;
   }
 }

 const fidl_type_t* Protocol_ResponseDecoder::GetType(uint64_t ordinal) {
   switch (ordinal) {
     case internal::kProtocol_RequestStrictResponseFlexible_Ordinal:
       return &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable;
     case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal:
       return &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable;
     default:
       return nullptr;
   }
 }

 Protocol_EventSender::~Protocol_EventSender() = default;

 Protocol_Sync::~Protocol_Sync() = default;

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

 Protocol_Proxy::~Protocol_Proxy() = default;

 zx_status_t Protocol_Proxy::Dispatch_(::fidl::HLCPPIncomingMessage message) {
   zx_status_t status = ZX_OK;
   switch (message.ordinal()) {
     default: {
       status = ZX_ERR_NOT_SUPPORTED;
       break;
     }
   }
   return status;
 }

 namespace {

 ::std::unique_ptr<::fidl::internal::SingleUseMessageHandler>
 Protocol_RequestStrictResponseFlexible_ResponseHandler(
     Protocol::RequestStrictResponseFlexibleCallback&& callback) {
   ZX_DEBUG_ASSERT_MSG(callback,
                       "Callback must not be empty for "
                       "Protocol::RequestStrictResponseFlexible\n");
   return ::std::make_unique<::fidl::internal::SingleUseMessageHandler>(
       [callback_ =
            std::move(callback)](::fidl::HLCPPIncomingMessage&& message) {
         ::fidl::Decoder decoder(std::move(message));
         callback_(::fidl::DecodeAs<
                   ::fidl::test::requestflexibleenvelope::FlexibleFoo>(&decoder,
                                                                       16));
         return ZX_OK;
       },
       &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable);
 }

 }  // namespace
 void Protocol_Proxy::RequestStrictResponseFlexible(
     ::fidl::test::requestflexibleenvelope::StrictFoo s,
     RequestStrictResponseFlexibleCallback callback) {
   ::fidl::Encoder _encoder(
       internal::kProtocol_RequestStrictResponseFlexible_Ordinal);
   controller_->Send(
       &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable,
       Protocol_RequestEncoder::RequestStrictResponseFlexible(&_encoder, &s),
       Protocol_RequestStrictResponseFlexible_ResponseHandler(
           std::move(callback)));
 }
 namespace {

 ::std::unique_ptr<::fidl::internal::SingleUseMessageHandler>
 Protocol_RequestFlexibleResponseStrict_ResponseHandler(
     Protocol::RequestFlexibleResponseStrictCallback&& callback) {
   ZX_DEBUG_ASSERT_MSG(callback,
                       "Callback must not be empty for "
                       "Protocol::RequestFlexibleResponseStrict\n");
   return ::std::make_unique<::fidl::internal::SingleUseMessageHandler>(
       [callback_ =
            std::move(callback)](::fidl::HLCPPIncomingMessage&& message) {
         ::fidl::Decoder decoder(std::move(message));
         callback_(
             ::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::StrictFoo>(
                 &decoder, 16));
         return ZX_OK;
       },
       &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable);
 }

 }  // namespace
 void Protocol_Proxy::RequestFlexibleResponseStrict(
     ::fidl::test::requestflexibleenvelope::FlexibleFoo s,
     RequestFlexibleResponseStrictCallback callback) {
   ::fidl::Encoder _encoder(
       internal::kProtocol_RequestFlexibleResponseStrict_Ordinal);
   controller_->Send(
       &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable,
       Protocol_RequestEncoder::RequestFlexibleResponseStrict(&_encoder, &s),
       Protocol_RequestFlexibleResponseStrict_ResponseHandler(
           std::move(callback)));
 }

 Protocol_Stub::Protocol_Stub(Protocol_clazz* impl) : impl_(impl) {
   (void)impl_;
 }

 Protocol_Stub::~Protocol_Stub() = default;

 namespace {

 class Protocol_RequestStrictResponseFlexible_Responder final {
  public:
   Protocol_RequestStrictResponseFlexible_Responder(
       ::fidl::internal::PendingResponse response)
       : response_(std::move(response)) {}

   void operator()(::fidl::test::requestflexibleenvelope::FlexibleFoo f) {
     ::fidl::Encoder _encoder(
         internal::kProtocol_RequestStrictResponseFlexible_Ordinal);
     response_.Send(
         &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable,
         Protocol_ResponseEncoder::RequestStrictResponseFlexible(&_encoder, &f));
   }

  private:
   ::fidl::internal::PendingResponse response_;
 };

 class Protocol_RequestFlexibleResponseStrict_Responder final {
  public:
   Protocol_RequestFlexibleResponseStrict_Responder(
       ::fidl::internal::PendingResponse response)
       : response_(std::move(response)) {}

   void operator()(::fidl::test::requestflexibleenvelope::StrictFoo f) {
     ::fidl::Encoder _encoder(
         internal::kProtocol_RequestFlexibleResponseStrict_Ordinal);
     response_.Send(
         &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable,
         Protocol_ResponseEncoder::RequestFlexibleResponseStrict(&_encoder, &f));
   }

  private:
   ::fidl::internal::PendingResponse response_;
 };

 }  // namespace

 zx_status_t Protocol_Stub::Dispatch_(
     ::fidl::HLCPPIncomingMessage message,
     ::fidl::internal::PendingResponse response) {
   bool needs_response;
   const fidl_type_t* request_type =
       Protocol_RequestDecoder::GetType(message.ordinal(), &needs_response);
   if (request_type == nullptr) {
     return ZX_ERR_NOT_SUPPORTED;
   }
   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;
   }
   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;
   }
   uint64_t ordinal = message.ordinal();
   switch (ordinal) {
     case internal::kProtocol_RequestStrictResponseFlexible_Ordinal: {
       ::fidl::Decoder decoder(std::move(message));
       impl_->RequestStrictResponseFlexible(
           ::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::StrictFoo>(
               &decoder, 16),
           Protocol_RequestStrictResponseFlexible_Responder(
               std::move(response)));
       break;
     }
     case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal: {
       ::fidl::Decoder decoder(std::move(message));
       impl_->RequestFlexibleResponseStrict(
           ::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::FlexibleFoo>(
               &decoder, 16),
           Protocol_RequestFlexibleResponseStrict_Responder(
               std::move(response)));
       break;
     }
     default: {
       status = ZX_ERR_NOT_SUPPORTED;
       break;
     }
   }
   return status;
 }

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

 Protocol_SyncProxy::~Protocol_SyncProxy() = default;

 zx_status_t Protocol_SyncProxy::RequestStrictResponseFlexible(
     ::fidl::test::requestflexibleenvelope::StrictFoo s,
     ::fidl::test::requestflexibleenvelope::FlexibleFoo* out_f) {
   ::fidl::Encoder _encoder(
       internal::kProtocol_RequestStrictResponseFlexible_Ordinal);
   ::fidl::IncomingMessageBuffer buffer_;
   ::fidl::HLCPPIncomingMessage response_ = buffer_.CreateEmptyIncomingMessage();
   zx_status_t status_ = proxy_.Call(
       &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable,
       &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable,
       Protocol_RequestEncoder::RequestStrictResponseFlexible(&_encoder, &s),
       &response_);
   if (status_ != ZX_OK) return status_;
   ::fidl::Decoder decoder_(std::move(response_));
   *out_f = ::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::FlexibleFoo>(
       &decoder_, 16);
   return ZX_OK;
 }

 zx_status_t Protocol_SyncProxy::RequestFlexibleResponseStrict(
     ::fidl::test::requestflexibleenvelope::FlexibleFoo s,
     ::fidl::test::requestflexibleenvelope::StrictFoo* out_f) {
   ::fidl::Encoder _encoder(
       internal::kProtocol_RequestFlexibleResponseStrict_Ordinal);
   ::fidl::IncomingMessageBuffer buffer_;
   ::fidl::HLCPPIncomingMessage response_ = buffer_.CreateEmptyIncomingMessage();
   zx_status_t status_ = proxy_.Call(
       &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable,
       &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable,
       Protocol_RequestEncoder::RequestFlexibleResponseStrict(&_encoder, &s),
       &response_);
   if (status_ != ZX_OK) return status_;
   ::fidl::Decoder decoder_(std::move(response_));
   *out_f = ::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::StrictFoo>(
       &decoder_, 16);
   return ZX_OK;
 }

 #endif  // __Fuchsia__

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

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

	#include "lib/fidl/cpp/internal/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 Tag::kS:
	new (&s_)::std::string();
	s_ = std::move(other.s_);
	break;
	case Tag::kI:
	i_ = std::move(other.i_);
	break;
	case static_cast<fidl_xunion_tag_t>(Tag::Invalid):
	break;
	}
	}

	StrictFoo& StrictFoo::operator=(StrictFoo&& other) {
	if (this != &other) {
	Destroy();
	tag_ = other.tag_;
	switch (tag_) {
	case Tag::kS:
	new (&s_)::std::string();
	s_ = std::move(other.s_);
	break;
	case Tag::kI:
	i_ = std::move(other.i_);
	break;
	case static_cast<fidl_xunion_tag_t>(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) {
	const size_t length_before = encoder->CurrentLength();
	const size_t handles_before = encoder->CurrentHandleCount();

	size_t envelope_offset = 0;

	switch (Which()) {
	case Tag::kS: {
	envelope_offset = encoder->Alloc(
	::fidl::EncodingInlineSize<::std::string, ::fidl::Encoder>(encoder));
	::fidl::Encode(encoder, &s_, envelope_offset);
	break;
	}
	case 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>(Tag::Invalid));
	return;
	}

	value->EnsureStorageInitialized(xunion->tag);

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

	switch (value->tag_) {
	case Tag::kS:
	new (&value->s_)::std::string();
	::fidl::Decode(decoder, &value->s_, envelope_offset);
	break;
	case 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 Tag::Invalid:
	return ZX_OK;
	case Tag::kS:
	new (&result->s_)::std::string();
	return ::fidl::Clone(s_, &result->s_);
	case Tag::kI:
	return ::fidl::Clone(i_, &result->i_);
	default:
	return ZX_OK;
	}
	}

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

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

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

	default:
	break;
	}
	tag_ = static_cast<fidl_xunion_tag_t>(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>(Tag::Invalid):
	break;
	case Tag::kS:
	new (&s_)::std::string();
	break;
	case 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 Tag::kS:
	new (&s_)::std::string();
	s_ = std::move(other.s_);
	break;
	case Tag::kI:
	i_ = std::move(other.i_);
	break;
	case static_cast<fidl_xunion_tag_t>(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 Tag::kS:
	new (&s_)::std::string();
	s_ = std::move(other.s_);
	break;
	case Tag::kI:
	i_ = std::move(other.i_);
	break;
	case static_cast<fidl_xunion_tag_t>(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) {
	const size_t length_before = encoder->CurrentLength();
	const size_t handles_before = encoder->CurrentHandleCount();

	size_t envelope_offset = 0;

	switch (Which()) {
	case Tag::kS: {
	envelope_offset = encoder->Alloc(
	::fidl::EncodingInlineSize<::std::string, ::fidl::Encoder>(encoder));
	::fidl::Encode(encoder, &s_, envelope_offset);
	break;
	}
	case Tag::kI: {
	envelope_offset = encoder->Alloc(
	::fidl::EncodingInlineSize<int32_t, ::fidl::Encoder>(encoder));
	::fidl::Encode(encoder, &i_, envelope_offset);
	break;
	}
	case 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>(Tag::Invalid));
	return;
	}

	value->EnsureStorageInitialized(xunion->tag);

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

	switch (value->tag_) {
	case Tag::kS:
	new (&value->s_)::std::string();
	::fidl::Decode(decoder, &value->s_, envelope_offset);
	break;
	case 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 Tag::Invalid:
	return ZX_OK;
	case Tag::kS:
	new (&result->s_)::std::string();
	return ::fidl::Clone(s_, &result->s_);
	case 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(Tag::kS);
	s_ = std::move(value);
	return *this;
	}

	FlexibleFoo& FlexibleFoo::set_i(int32_t value) {
	EnsureStorageInitialized(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 Tag::kS:
	s_.~decltype(s_)();
	break;
	case Tag::kI:
	break;

	case static_cast<fidl_xunion_tag_t>(Tag::Invalid):
	break;
	default:
	unknown_data_.~decltype(unknown_data_)();
	break;
	}
	tag_ = static_cast<fidl_xunion_tag_t>(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>(Tag::Invalid):
	break;
	case Tag::kS:
	new (&s_)::std::string();
	break;
	case Tag::kI:
	new (&i_) int32_t();
	break;
	default:
	new (&unknown_data_) decltype(unknown_data_);
	break;
	}
	}
	}
	} // namespace requestflexibleenvelope
	} // namespace test
	} // namespace fidl

	//
	// Proxies and stubs definitions
	//
	namespace fidl {
	namespace test {
	namespace requestflexibleenvelope {

	#ifdef __Fuchsia__
	namespace {

	extern "C" const fidl_type_t
	fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable;
	extern "C" const fidl_type_t
	fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable;

	extern "C" const fidl_type_t
	fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable;
	extern "C" const fidl_type_t
	fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable;

	} // namespace

	Protocol::~Protocol() = default;

	const fidl_type_t* Protocol_RequestDecoder::GetType(uint64_t ordinal,
	bool* out_needs_response) {
	switch (ordinal) {
	case internal::kProtocol_RequestStrictResponseFlexible_Ordinal:
	*out_needs_response = true;
	return &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable;
	case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal:
	*out_needs_response = true;
	return &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable;
	default:
	*out_needs_response = false;
	return nullptr;
	}
	}

	const fidl_type_t* Protocol_ResponseDecoder::GetType(uint64_t ordinal) {
	switch (ordinal) {
	case internal::kProtocol_RequestStrictResponseFlexible_Ordinal:
	return &fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable;
	case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal:
	return &fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable;
	default:
	return nullptr;
	}
	}

	Protocol_EventSender::~Protocol_EventSender() = default;

	Protocol_Sync::~Protocol_Sync() = default;

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

	Protocol_Proxy::~Protocol_Proxy() = default;

	zx_status_t Protocol_Proxy::Dispatch_(::fidl::HLCPPIncomingMessage message) {
	zx_status_t status = ZX_OK;
	switch (message.ordinal()) {
	default: {
	status = ZX_ERR_NOT_SUPPORTED;
	break;
	}
	}
	return status;
	}

	namespace {

	::std::unique_ptr<::fidl::internal::SingleUseMessageHandler>
	Protocol_RequestStrictResponseFlexible_ResponseHandler(
	Protocol::RequestStrictResponseFlexibleCallback&& callback) {
	ZX_DEBUG_ASSERT_MSG(callback,
	"Callback must not be empty for "
	"Protocol::RequestStrictResponseFlexible\n");
	return ::std::make_unique<::fidl::internal::SingleUseMessageHandler>(
	[callback_ =
	std::move(callback)](::fidl::HLCPPIncomingMessage&& message) {
	::fidl::Decoder decoder(std::move(message));
	callback_(::fidl::DecodeAs<
	::fidl::test::requestflexibleenvelope::FlexibleFoo>(&decoder,
	16));
	return ZX_OK;
	},
	&fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable);
	}

	} // namespace
	void Protocol_Proxy::RequestStrictResponseFlexible(
	::fidl::test::requestflexibleenvelope::StrictFoo s,
	RequestStrictResponseFlexibleCallback callback) {
	::fidl::Encoder _encoder(
	internal::kProtocol_RequestStrictResponseFlexible_Ordinal);
	controller_->Send(
	&fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable,
	Protocol_RequestEncoder::RequestStrictResponseFlexible(&_encoder, &s),
	Protocol_RequestStrictResponseFlexible_ResponseHandler(
	std::move(callback)));
	}
	namespace {

	::std::unique_ptr<::fidl::internal::SingleUseMessageHandler>
	Protocol_RequestFlexibleResponseStrict_ResponseHandler(
	Protocol::RequestFlexibleResponseStrictCallback&& callback) {
	ZX_DEBUG_ASSERT_MSG(callback,
	"Callback must not be empty for "
	"Protocol::RequestFlexibleResponseStrict\n");
	return ::std::make_unique<::fidl::internal::SingleUseMessageHandler>(
	[callback_ =
	std::move(callback)](::fidl::HLCPPIncomingMessage&& message) {
	::fidl::Decoder decoder(std::move(message));
	callback_(
	::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::StrictFoo>(
	&decoder, 16));
	return ZX_OK;
	},
	&fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable);
	}

	} // namespace
	void Protocol_Proxy::RequestFlexibleResponseStrict(
	::fidl::test::requestflexibleenvelope::FlexibleFoo s,
	RequestFlexibleResponseStrictCallback callback) {
	::fidl::Encoder _encoder(
	internal::kProtocol_RequestFlexibleResponseStrict_Ordinal);
	controller_->Send(
	&fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable,
	Protocol_RequestEncoder::RequestFlexibleResponseStrict(&_encoder, &s),
	Protocol_RequestFlexibleResponseStrict_ResponseHandler(
	std::move(callback)));
	}

	Protocol_Stub::Protocol_Stub(Protocol_clazz* impl) : impl_(impl) {
	(void)impl_;
	}

	Protocol_Stub::~Protocol_Stub() = default;

	namespace {

	class Protocol_RequestStrictResponseFlexible_Responder final {
	public:
	Protocol_RequestStrictResponseFlexible_Responder(
	::fidl::internal::PendingResponse response)
	: response_(std::move(response)) {}

	void operator()(::fidl::test::requestflexibleenvelope::FlexibleFoo f) {
	::fidl::Encoder _encoder(
	internal::kProtocol_RequestStrictResponseFlexible_Ordinal);
	response_.Send(
	&fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable,
	Protocol_ResponseEncoder::RequestStrictResponseFlexible(&_encoder, &f));
	}

	private:
	::fidl::internal::PendingResponse response_;
	};

	class Protocol_RequestFlexibleResponseStrict_Responder final {
	public:
	Protocol_RequestFlexibleResponseStrict_Responder(
	::fidl::internal::PendingResponse response)
	: response_(std::move(response)) {}

	void operator()(::fidl::test::requestflexibleenvelope::StrictFoo f) {
	::fidl::Encoder _encoder(
	internal::kProtocol_RequestFlexibleResponseStrict_Ordinal);
	response_.Send(
	&fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable,
	Protocol_ResponseEncoder::RequestFlexibleResponseStrict(&_encoder, &f));
	}

	private:
	::fidl::internal::PendingResponse response_;
	};

	} // namespace

	zx_status_t Protocol_Stub::Dispatch_(
	::fidl::HLCPPIncomingMessage message,
	::fidl::internal::PendingResponse response) {
	bool needs_response;
	const fidl_type_t* request_type =
	Protocol_RequestDecoder::GetType(message.ordinal(), &needs_response);
	if (request_type == nullptr) {
	return ZX_ERR_NOT_SUPPORTED;
	}
	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;
	}
	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;
	}
	uint64_t ordinal = message.ordinal();
	switch (ordinal) {
	case internal::kProtocol_RequestStrictResponseFlexible_Ordinal: {
	::fidl::Decoder decoder(std::move(message));
	impl_->RequestStrictResponseFlexible(
	::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::StrictFoo>(
	&decoder, 16),
	Protocol_RequestStrictResponseFlexible_Responder(
	std::move(response)));
	break;
	}
	case internal::kProtocol_RequestFlexibleResponseStrict_Ordinal: {
	::fidl::Decoder decoder(std::move(message));
	impl_->RequestFlexibleResponseStrict(
	::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::FlexibleFoo>(
	&decoder, 16),
	Protocol_RequestFlexibleResponseStrict_Responder(
	std::move(response)));
	break;
	}
	default: {
	status = ZX_ERR_NOT_SUPPORTED;
	break;
	}
	}
	return status;
	}

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

	Protocol_SyncProxy::~Protocol_SyncProxy() = default;

	zx_status_t Protocol_SyncProxy::RequestStrictResponseFlexible(
	::fidl::test::requestflexibleenvelope::StrictFoo s,
	::fidl::test::requestflexibleenvelope::FlexibleFoo* out_f) {
	::fidl::Encoder _encoder(
	internal::kProtocol_RequestStrictResponseFlexible_Ordinal);
	::fidl::IncomingMessageBuffer buffer_;
	::fidl::HLCPPIncomingMessage response_ = buffer_.CreateEmptyIncomingMessage();
	zx_status_t status_ = proxy_.Call(
	&fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleRequestTable,
	&fidl_test_requestflexibleenvelope_ProtocolRequestStrictResponseFlexibleResponseTable,
	Protocol_RequestEncoder::RequestStrictResponseFlexible(&_encoder, &s),
	&response_);
	if (status_ != ZX_OK) return status_;
	::fidl::Decoder decoder_(std::move(response_));
	*out_f = ::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::FlexibleFoo>(
	&decoder_, 16);
	return ZX_OK;
	}

	zx_status_t Protocol_SyncProxy::RequestFlexibleResponseStrict(
	::fidl::test::requestflexibleenvelope::FlexibleFoo s,
	::fidl::test::requestflexibleenvelope::StrictFoo* out_f) {
	::fidl::Encoder _encoder(
	internal::kProtocol_RequestFlexibleResponseStrict_Ordinal);
	::fidl::IncomingMessageBuffer buffer_;
	::fidl::HLCPPIncomingMessage response_ = buffer_.CreateEmptyIncomingMessage();
	zx_status_t status_ = proxy_.Call(
	&fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictRequestTable,
	&fidl_test_requestflexibleenvelope_ProtocolRequestFlexibleResponseStrictResponseTable,
	Protocol_RequestEncoder::RequestFlexibleResponseStrict(&_encoder, &s),
	&response_);
	if (status_ != ZX_OK) return status_;
	::fidl::Decoder decoder_(std::move(response_));
	*out_f = ::fidl::DecodeAs<::fidl::test::requestflexibleenvelope::StrictFoo>(
	&decoder_, 16);
	return ZX_OK;
	}

	#endif // __Fuchsia__

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