| // WARNING: This file is machine generated by fidlgen. |
| |
| // fidl_experiment = output_index_json |
| |
| #pragma once |
| |
| #include "lib/fidl/cpp/internal/header.h" |
| |
| namespace test { |
| namespace union_ { |
| |
| |
| // |
| // Domain objects declarations |
| // |
| |
| |
| class Pizza; |
| |
| |
| class Pasta; |
| |
| |
| class PizzaOrPasta; |
| |
| |
| class ExplicitPizzaOrPasta; |
| |
| |
| class FlexiblePizzaOrPasta; |
| |
| |
| class StrictPizzaOrPasta; |
| |
| |
| class Union; |
| |
| |
| class FlexibleUnion; |
| |
| |
| class StrictUnion; |
| |
| |
| class FieldCollision; |
| |
| |
| class ExplicitUnion; |
| |
| |
| class ReverseOrdinalUnion; |
| |
| |
| class NullableUnionStruct; |
| |
| |
| class FlexibleFoo; |
| |
| |
| class StrictFoo; |
| |
| |
| class ExplicitFoo; |
| |
| |
| class ExplicitStrictFoo; |
| |
| |
| class OlderSimpleUnion; |
| |
| |
| class NewerSimpleUnion; |
| |
| |
| class StrictSimpleUnion; |
| |
| |
| class Empty; |
| |
| |
| class UnionContainingEmptyStruct; |
| |
| |
| class StrictBoundedUnion; |
| |
| |
| class TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse; |
| |
| |
| class TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| class TestProtocol; |
| using TestProtocolHandle = ::fidl::InterfaceHandle<TestProtocol>; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| class StructWithNullableUnion; |
| |
| |
| class ExplicitFlexibleUnion; |
| |
| |
| class UnionSandwich; |
| |
| |
| class UnionWithAttributes; |
| |
| |
| class EmptyFlexibleUnion; |
| |
| |
| |
| class Pizza final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::std::vector<::std::string> toppings; |
| |
| static inline ::std::unique_ptr<Pizza> New() { return ::std::make_unique<Pizza>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, Pizza* value, size_t _offset); |
| zx_status_t Clone(Pizza* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::Pizza& _value, |
| ::test::union_::Pizza* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using PizzaPtr = ::std::unique_ptr<Pizza>; |
| |
| |
| |
| class Pasta final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::std::string sauce; |
| |
| static inline ::std::unique_ptr<Pasta> New() { return ::std::make_unique<Pasta>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, Pasta* value, size_t _offset); |
| zx_status_t Clone(Pasta* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::Pasta& _value, |
| ::test::union_::Pasta* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using PastaPtr = ::std::unique_ptr<Pasta>; |
| |
| |
| |
| class PizzaOrPasta final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| PizzaOrPasta(); |
| ~PizzaOrPasta(); |
| |
| PizzaOrPasta(PizzaOrPasta&&); |
| PizzaOrPasta& operator=(PizzaOrPasta&&); |
| |
| |
| static PizzaOrPasta WithPizza(::test::union_::Pizza&&); |
| static PizzaOrPasta WithPasta(::test::union_::Pasta&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kPizza = 1, // 0x1 |
| kPasta = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<PizzaOrPasta> New() { return ::std::make_unique<PizzaOrPasta>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, PizzaOrPasta* value, size_t offset); |
| zx_status_t Clone(PizzaOrPasta* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_pizza() const { return tag_ == ::test::union_::PizzaOrPasta::Tag::kPizza; } |
| |
| ::test::union_::Pizza& pizza() { |
| EnsureStorageInitialized(::test::union_::PizzaOrPasta::Tag::kPizza); |
| return pizza_; |
| } |
| |
| const ::test::union_::Pizza& pizza() const { |
| ZX_ASSERT(is_pizza()); |
| return pizza_; |
| } |
| PizzaOrPasta& set_pizza(::test::union_::Pizza value); |
| |
| bool is_pasta() const { return tag_ == ::test::union_::PizzaOrPasta::Tag::kPasta; } |
| |
| ::test::union_::Pasta& pasta() { |
| EnsureStorageInitialized(::test::union_::PizzaOrPasta::Tag::kPasta); |
| return pasta_; |
| } |
| |
| const ::test::union_::Pasta& pasta() const { |
| ZX_ASSERT(is_pasta()); |
| return pasta_; |
| } |
| PizzaOrPasta& set_pasta(::test::union_::Pasta value); |
| |
| ::test::union_::PizzaOrPasta::Tag Which() const { |
| |
| return ::test::union_::PizzaOrPasta::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::PizzaOrPasta>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::PizzaOrPasta::Tag::Invalid); |
| union { |
| ::test::union_::Pizza pizza_; |
| ::test::union_::Pasta pasta_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::PizzaOrPasta& value, |
| ::test::union_::PizzaOrPasta* result) { |
| return value.Clone(result); |
| } |
| |
| using PizzaOrPastaPtr = ::std::unique_ptr<PizzaOrPasta>; |
| |
| |
| |
| class ExplicitPizzaOrPasta final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ExplicitPizzaOrPasta(); |
| ~ExplicitPizzaOrPasta(); |
| |
| ExplicitPizzaOrPasta(ExplicitPizzaOrPasta&&); |
| ExplicitPizzaOrPasta& operator=(ExplicitPizzaOrPasta&&); |
| |
| |
| static ExplicitPizzaOrPasta WithPizza(::test::union_::Pizza&&); |
| static ExplicitPizzaOrPasta WithPasta(::test::union_::Pasta&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kPizza = 1, // 0x1 |
| kPasta = 4, // 0x4 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ExplicitPizzaOrPasta> New() { return ::std::make_unique<ExplicitPizzaOrPasta>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ExplicitPizzaOrPasta* value, size_t offset); |
| zx_status_t Clone(ExplicitPizzaOrPasta* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_pizza() const { return tag_ == ::test::union_::ExplicitPizzaOrPasta::Tag::kPizza; } |
| |
| ::test::union_::Pizza& pizza() { |
| EnsureStorageInitialized(::test::union_::ExplicitPizzaOrPasta::Tag::kPizza); |
| return pizza_; |
| } |
| |
| const ::test::union_::Pizza& pizza() const { |
| ZX_ASSERT(is_pizza()); |
| return pizza_; |
| } |
| ExplicitPizzaOrPasta& set_pizza(::test::union_::Pizza value); |
| |
| bool is_pasta() const { return tag_ == ::test::union_::ExplicitPizzaOrPasta::Tag::kPasta; } |
| |
| ::test::union_::Pasta& pasta() { |
| EnsureStorageInitialized(::test::union_::ExplicitPizzaOrPasta::Tag::kPasta); |
| return pasta_; |
| } |
| |
| const ::test::union_::Pasta& pasta() const { |
| ZX_ASSERT(is_pasta()); |
| return pasta_; |
| } |
| ExplicitPizzaOrPasta& set_pasta(::test::union_::Pasta value); |
| |
| ::test::union_::ExplicitPizzaOrPasta::Tag Which() const { |
| |
| return ::test::union_::ExplicitPizzaOrPasta::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::ExplicitPizzaOrPasta>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitPizzaOrPasta::Tag::Invalid); |
| union { |
| ::test::union_::Pizza pizza_; |
| ::test::union_::Pasta pasta_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitPizzaOrPasta& value, |
| ::test::union_::ExplicitPizzaOrPasta* result) { |
| return value.Clone(result); |
| } |
| |
| using ExplicitPizzaOrPastaPtr = ::std::unique_ptr<ExplicitPizzaOrPasta>; |
| |
| |
| |
| class FlexiblePizzaOrPasta final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| FlexiblePizzaOrPasta(); |
| ~FlexiblePizzaOrPasta(); |
| |
| FlexiblePizzaOrPasta(FlexiblePizzaOrPasta&&); |
| FlexiblePizzaOrPasta& operator=(FlexiblePizzaOrPasta&&); |
| |
| |
| static FlexiblePizzaOrPasta WithPizza(::test::union_::Pizza&&); |
| static FlexiblePizzaOrPasta WithPasta(::test::union_::Pasta&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kPizza = 1, // 0x1 |
| kPasta = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<FlexiblePizzaOrPasta> New() { return ::std::make_unique<FlexiblePizzaOrPasta>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, FlexiblePizzaOrPasta* value, size_t offset); |
| zx_status_t Clone(FlexiblePizzaOrPasta* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_pizza() const { return tag_ == ::test::union_::FlexiblePizzaOrPasta::Tag::kPizza; } |
| |
| ::test::union_::Pizza& pizza() { |
| EnsureStorageInitialized(::test::union_::FlexiblePizzaOrPasta::Tag::kPizza); |
| return pizza_; |
| } |
| |
| const ::test::union_::Pizza& pizza() const { |
| ZX_ASSERT(is_pizza()); |
| return pizza_; |
| } |
| FlexiblePizzaOrPasta& set_pizza(::test::union_::Pizza value); |
| |
| bool is_pasta() const { return tag_ == ::test::union_::FlexiblePizzaOrPasta::Tag::kPasta; } |
| |
| ::test::union_::Pasta& pasta() { |
| EnsureStorageInitialized(::test::union_::FlexiblePizzaOrPasta::Tag::kPasta); |
| return pasta_; |
| } |
| |
| const ::test::union_::Pasta& pasta() const { |
| ZX_ASSERT(is_pasta()); |
| return pasta_; |
| } |
| FlexiblePizzaOrPasta& set_pasta(::test::union_::Pasta value); |
| FlexiblePizzaOrPasta& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::FlexiblePizzaOrPasta::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::FlexiblePizzaOrPasta::Tag::Invalid: |
| case ::test::union_::FlexiblePizzaOrPasta::Tag::kPizza: |
| case ::test::union_::FlexiblePizzaOrPasta::Tag::kPasta: |
| return ::test::union_::FlexiblePizzaOrPasta::Tag(tag_); |
| default: |
| return ::test::union_::FlexiblePizzaOrPasta::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::FlexiblePizzaOrPasta::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::FlexiblePizzaOrPasta>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FlexiblePizzaOrPasta::Tag::Invalid); |
| union { |
| ::test::union_::Pizza pizza_; |
| ::test::union_::Pasta pasta_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FlexiblePizzaOrPasta& value, |
| ::test::union_::FlexiblePizzaOrPasta* result) { |
| return value.Clone(result); |
| } |
| |
| using FlexiblePizzaOrPastaPtr = ::std::unique_ptr<FlexiblePizzaOrPasta>; |
| |
| |
| |
| class StrictPizzaOrPasta final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| StrictPizzaOrPasta(); |
| ~StrictPizzaOrPasta(); |
| |
| StrictPizzaOrPasta(StrictPizzaOrPasta&&); |
| StrictPizzaOrPasta& operator=(StrictPizzaOrPasta&&); |
| |
| |
| static StrictPizzaOrPasta WithPizza(::test::union_::Pizza&&); |
| static StrictPizzaOrPasta WithPasta(::test::union_::Pasta&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kPizza = 1, // 0x1 |
| kPasta = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<StrictPizzaOrPasta> New() { return ::std::make_unique<StrictPizzaOrPasta>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, StrictPizzaOrPasta* value, size_t offset); |
| zx_status_t Clone(StrictPizzaOrPasta* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_pizza() const { return tag_ == ::test::union_::StrictPizzaOrPasta::Tag::kPizza; } |
| |
| ::test::union_::Pizza& pizza() { |
| EnsureStorageInitialized(::test::union_::StrictPizzaOrPasta::Tag::kPizza); |
| return pizza_; |
| } |
| |
| const ::test::union_::Pizza& pizza() const { |
| ZX_ASSERT(is_pizza()); |
| return pizza_; |
| } |
| StrictPizzaOrPasta& set_pizza(::test::union_::Pizza value); |
| |
| bool is_pasta() const { return tag_ == ::test::union_::StrictPizzaOrPasta::Tag::kPasta; } |
| |
| ::test::union_::Pasta& pasta() { |
| EnsureStorageInitialized(::test::union_::StrictPizzaOrPasta::Tag::kPasta); |
| return pasta_; |
| } |
| |
| const ::test::union_::Pasta& pasta() const { |
| ZX_ASSERT(is_pasta()); |
| return pasta_; |
| } |
| StrictPizzaOrPasta& set_pasta(::test::union_::Pasta value); |
| |
| ::test::union_::StrictPizzaOrPasta::Tag Which() const { |
| |
| return ::test::union_::StrictPizzaOrPasta::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::StrictPizzaOrPasta>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictPizzaOrPasta::Tag::Invalid); |
| union { |
| ::test::union_::Pizza pizza_; |
| ::test::union_::Pasta pasta_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictPizzaOrPasta& value, |
| ::test::union_::StrictPizzaOrPasta* result) { |
| return value.Clone(result); |
| } |
| |
| using StrictPizzaOrPastaPtr = ::std::unique_ptr<StrictPizzaOrPasta>; |
| |
| |
| |
| class Union final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| Union(); |
| ~Union(); |
| |
| Union(Union&&); |
| Union& operator=(Union&&); |
| |
| |
| static Union WithPrimitive(int32_t&&); |
| static Union WithStringNeedsConstructor(::std::string&&); |
| static Union WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string>&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kPrimitive = 1, // 0x1 |
| kStringNeedsConstructor = 2, // 0x2 |
| kVectorStringAlsoNeedsConstructor = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<Union> New() { return ::std::make_unique<Union>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, Union* value, size_t offset); |
| zx_status_t Clone(Union* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_Primitive() const { return tag_ == ::test::union_::Union::Tag::kPrimitive; } |
| |
| int32_t& Primitive() { |
| EnsureStorageInitialized(::test::union_::Union::Tag::kPrimitive); |
| return Primitive_; |
| } |
| |
| const int32_t& Primitive() const { |
| ZX_ASSERT(is_Primitive()); |
| return Primitive_; |
| } |
| Union& set_Primitive(int32_t value); |
| |
| bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::Union::Tag::kStringNeedsConstructor; } |
| |
| ::std::string& StringNeedsConstructor() { |
| EnsureStorageInitialized(::test::union_::Union::Tag::kStringNeedsConstructor); |
| return StringNeedsConstructor_; |
| } |
| |
| const ::std::string& StringNeedsConstructor() const { |
| ZX_ASSERT(is_StringNeedsConstructor()); |
| return StringNeedsConstructor_; |
| } |
| Union& set_StringNeedsConstructor(::std::string value); |
| |
| bool is_VectorStringAlsoNeedsConstructor() const { return tag_ == ::test::union_::Union::Tag::kVectorStringAlsoNeedsConstructor; } |
| |
| ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() { |
| EnsureStorageInitialized(::test::union_::Union::Tag::kVectorStringAlsoNeedsConstructor); |
| return VectorStringAlsoNeedsConstructor_; |
| } |
| |
| const ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() const { |
| ZX_ASSERT(is_VectorStringAlsoNeedsConstructor()); |
| return VectorStringAlsoNeedsConstructor_; |
| } |
| Union& set_VectorStringAlsoNeedsConstructor(::std::vector<::std::string> value); |
| |
| ::test::union_::Union::Tag Which() const { |
| |
| return ::test::union_::Union::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::Union>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::Union::Tag::Invalid); |
| union { |
| int32_t Primitive_; |
| ::std::string StringNeedsConstructor_; |
| ::std::vector<::std::string> VectorStringAlsoNeedsConstructor_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::Union& value, |
| ::test::union_::Union* result) { |
| return value.Clone(result); |
| } |
| |
| using UnionPtr = ::std::unique_ptr<Union>; |
| |
| |
| |
| class FlexibleUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| FlexibleUnion(); |
| ~FlexibleUnion(); |
| |
| FlexibleUnion(FlexibleUnion&&); |
| FlexibleUnion& operator=(FlexibleUnion&&); |
| |
| |
| static FlexibleUnion WithPrimitive(int32_t&&); |
| static FlexibleUnion WithStringNeedsConstructor(::std::string&&); |
| static FlexibleUnion WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string>&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kPrimitive = 1, // 0x1 |
| kStringNeedsConstructor = 2, // 0x2 |
| kVectorStringAlsoNeedsConstructor = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<FlexibleUnion> New() { return ::std::make_unique<FlexibleUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, FlexibleUnion* value, size_t offset); |
| zx_status_t Clone(FlexibleUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_Primitive() const { return tag_ == ::test::union_::FlexibleUnion::Tag::kPrimitive; } |
| |
| int32_t& Primitive() { |
| EnsureStorageInitialized(::test::union_::FlexibleUnion::Tag::kPrimitive); |
| return Primitive_; |
| } |
| |
| const int32_t& Primitive() const { |
| ZX_ASSERT(is_Primitive()); |
| return Primitive_; |
| } |
| FlexibleUnion& set_Primitive(int32_t value); |
| |
| bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor; } |
| |
| ::std::string& StringNeedsConstructor() { |
| EnsureStorageInitialized(::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor); |
| return StringNeedsConstructor_; |
| } |
| |
| const ::std::string& StringNeedsConstructor() const { |
| ZX_ASSERT(is_StringNeedsConstructor()); |
| return StringNeedsConstructor_; |
| } |
| FlexibleUnion& set_StringNeedsConstructor(::std::string value); |
| |
| bool is_VectorStringAlsoNeedsConstructor() const { return tag_ == ::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor; } |
| |
| ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() { |
| EnsureStorageInitialized(::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor); |
| return VectorStringAlsoNeedsConstructor_; |
| } |
| |
| const ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() const { |
| ZX_ASSERT(is_VectorStringAlsoNeedsConstructor()); |
| return VectorStringAlsoNeedsConstructor_; |
| } |
| FlexibleUnion& set_VectorStringAlsoNeedsConstructor(::std::vector<::std::string> value); |
| FlexibleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::FlexibleUnion::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::FlexibleUnion::Tag::Invalid: |
| case ::test::union_::FlexibleUnion::Tag::kPrimitive: |
| case ::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor: |
| case ::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor: |
| return ::test::union_::FlexibleUnion::Tag(tag_); |
| default: |
| return ::test::union_::FlexibleUnion::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::FlexibleUnion::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::FlexibleUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleUnion::Tag::Invalid); |
| union { |
| int32_t Primitive_; |
| ::std::string StringNeedsConstructor_; |
| ::std::vector<::std::string> VectorStringAlsoNeedsConstructor_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FlexibleUnion& value, |
| ::test::union_::FlexibleUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using FlexibleUnionPtr = ::std::unique_ptr<FlexibleUnion>; |
| |
| |
| |
| class StrictUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| StrictUnion(); |
| ~StrictUnion(); |
| |
| StrictUnion(StrictUnion&&); |
| StrictUnion& operator=(StrictUnion&&); |
| |
| |
| static StrictUnion WithPrimitive(int32_t&&); |
| static StrictUnion WithStringNeedsConstructor(::std::string&&); |
| static StrictUnion WithVectorStringAlsoNeedsConstructor(::std::vector<::std::string>&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kPrimitive = 1, // 0x1 |
| kStringNeedsConstructor = 2, // 0x2 |
| kVectorStringAlsoNeedsConstructor = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<StrictUnion> New() { return ::std::make_unique<StrictUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, StrictUnion* value, size_t offset); |
| zx_status_t Clone(StrictUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_Primitive() const { return tag_ == ::test::union_::StrictUnion::Tag::kPrimitive; } |
| |
| int32_t& Primitive() { |
| EnsureStorageInitialized(::test::union_::StrictUnion::Tag::kPrimitive); |
| return Primitive_; |
| } |
| |
| const int32_t& Primitive() const { |
| ZX_ASSERT(is_Primitive()); |
| return Primitive_; |
| } |
| StrictUnion& set_Primitive(int32_t value); |
| |
| bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::StrictUnion::Tag::kStringNeedsConstructor; } |
| |
| ::std::string& StringNeedsConstructor() { |
| EnsureStorageInitialized(::test::union_::StrictUnion::Tag::kStringNeedsConstructor); |
| return StringNeedsConstructor_; |
| } |
| |
| const ::std::string& StringNeedsConstructor() const { |
| ZX_ASSERT(is_StringNeedsConstructor()); |
| return StringNeedsConstructor_; |
| } |
| StrictUnion& set_StringNeedsConstructor(::std::string value); |
| |
| bool is_VectorStringAlsoNeedsConstructor() const { return tag_ == ::test::union_::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor; } |
| |
| ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() { |
| EnsureStorageInitialized(::test::union_::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor); |
| return VectorStringAlsoNeedsConstructor_; |
| } |
| |
| const ::std::vector<::std::string>& VectorStringAlsoNeedsConstructor() const { |
| ZX_ASSERT(is_VectorStringAlsoNeedsConstructor()); |
| return VectorStringAlsoNeedsConstructor_; |
| } |
| StrictUnion& set_VectorStringAlsoNeedsConstructor(::std::vector<::std::string> value); |
| |
| ::test::union_::StrictUnion::Tag Which() const { |
| |
| return ::test::union_::StrictUnion::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::StrictUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictUnion::Tag::Invalid); |
| union { |
| int32_t Primitive_; |
| ::std::string StringNeedsConstructor_; |
| ::std::vector<::std::string> VectorStringAlsoNeedsConstructor_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictUnion& value, |
| ::test::union_::StrictUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using StrictUnionPtr = ::std::unique_ptr<StrictUnion>; |
| |
| |
| |
| class FieldCollision final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| FieldCollision(); |
| ~FieldCollision(); |
| |
| FieldCollision(FieldCollision&&); |
| FieldCollision& operator=(FieldCollision&&); |
| |
| |
| static FieldCollision WithFieldCollisionTag(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kFieldCollisionTag = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<FieldCollision> New() { return ::std::make_unique<FieldCollision>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, FieldCollision* value, size_t offset); |
| zx_status_t Clone(FieldCollision* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_field_collision_tag() const { return tag_ == ::test::union_::FieldCollision::Tag::kFieldCollisionTag; } |
| |
| int32_t& field_collision_tag() { |
| EnsureStorageInitialized(::test::union_::FieldCollision::Tag::kFieldCollisionTag); |
| return field_collision_tag_; |
| } |
| |
| const int32_t& field_collision_tag() const { |
| ZX_ASSERT(is_field_collision_tag()); |
| return field_collision_tag_; |
| } |
| FieldCollision& set_field_collision_tag(int32_t value); |
| |
| ::test::union_::FieldCollision::Tag Which() const { |
| |
| return ::test::union_::FieldCollision::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::FieldCollision>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FieldCollision::Tag::Invalid); |
| union { |
| int32_t field_collision_tag_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FieldCollision& value, |
| ::test::union_::FieldCollision* result) { |
| return value.Clone(result); |
| } |
| |
| using FieldCollisionPtr = ::std::unique_ptr<FieldCollision>; |
| |
| |
| |
| class ExplicitUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ExplicitUnion(); |
| ~ExplicitUnion(); |
| |
| ExplicitUnion(ExplicitUnion&&); |
| ExplicitUnion& operator=(ExplicitUnion&&); |
| |
| |
| static ExplicitUnion WithPrimitive(int32_t&&); |
| static ExplicitUnion WithStringNeedsConstructor(::std::string&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kPrimitive = 1, // 0x1 |
| kStringNeedsConstructor = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ExplicitUnion> New() { return ::std::make_unique<ExplicitUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ExplicitUnion* value, size_t offset); |
| zx_status_t Clone(ExplicitUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_Primitive() const { return tag_ == ::test::union_::ExplicitUnion::Tag::kPrimitive; } |
| |
| int32_t& Primitive() { |
| EnsureStorageInitialized(::test::union_::ExplicitUnion::Tag::kPrimitive); |
| return Primitive_; |
| } |
| |
| const int32_t& Primitive() const { |
| ZX_ASSERT(is_Primitive()); |
| return Primitive_; |
| } |
| ExplicitUnion& set_Primitive(int32_t value); |
| |
| bool is_StringNeedsConstructor() const { return tag_ == ::test::union_::ExplicitUnion::Tag::kStringNeedsConstructor; } |
| |
| ::std::string& StringNeedsConstructor() { |
| EnsureStorageInitialized(::test::union_::ExplicitUnion::Tag::kStringNeedsConstructor); |
| return StringNeedsConstructor_; |
| } |
| |
| const ::std::string& StringNeedsConstructor() const { |
| ZX_ASSERT(is_StringNeedsConstructor()); |
| return StringNeedsConstructor_; |
| } |
| ExplicitUnion& set_StringNeedsConstructor(::std::string value); |
| |
| ::test::union_::ExplicitUnion::Tag Which() const { |
| |
| return ::test::union_::ExplicitUnion::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::ExplicitUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitUnion::Tag::Invalid); |
| union { |
| int32_t Primitive_; |
| ::std::string StringNeedsConstructor_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitUnion& value, |
| ::test::union_::ExplicitUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using ExplicitUnionPtr = ::std::unique_ptr<ExplicitUnion>; |
| |
| |
| |
| class ReverseOrdinalUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ReverseOrdinalUnion(); |
| ~ReverseOrdinalUnion(); |
| |
| ReverseOrdinalUnion(ReverseOrdinalUnion&&); |
| ReverseOrdinalUnion& operator=(ReverseOrdinalUnion&&); |
| |
| |
| static ReverseOrdinalUnion WithFirst(uint32_t&&); |
| static ReverseOrdinalUnion WithSecond(uint32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kFirst = 1, // 0x1 |
| kSecond = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ReverseOrdinalUnion> New() { return ::std::make_unique<ReverseOrdinalUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ReverseOrdinalUnion* value, size_t offset); |
| zx_status_t Clone(ReverseOrdinalUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_first() const { return tag_ == ::test::union_::ReverseOrdinalUnion::Tag::kFirst; } |
| |
| uint32_t& first() { |
| EnsureStorageInitialized(::test::union_::ReverseOrdinalUnion::Tag::kFirst); |
| return first_; |
| } |
| |
| const uint32_t& first() const { |
| ZX_ASSERT(is_first()); |
| return first_; |
| } |
| ReverseOrdinalUnion& set_first(uint32_t value); |
| |
| bool is_second() const { return tag_ == ::test::union_::ReverseOrdinalUnion::Tag::kSecond; } |
| |
| uint32_t& second() { |
| EnsureStorageInitialized(::test::union_::ReverseOrdinalUnion::Tag::kSecond); |
| return second_; |
| } |
| |
| const uint32_t& second() const { |
| ZX_ASSERT(is_second()); |
| return second_; |
| } |
| ReverseOrdinalUnion& set_second(uint32_t value); |
| |
| ::test::union_::ReverseOrdinalUnion::Tag Which() const { |
| |
| return ::test::union_::ReverseOrdinalUnion::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::ReverseOrdinalUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ReverseOrdinalUnion::Tag::Invalid); |
| union { |
| uint32_t first_; |
| uint32_t second_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ReverseOrdinalUnion& value, |
| ::test::union_::ReverseOrdinalUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using ReverseOrdinalUnionPtr = ::std::unique_ptr<ReverseOrdinalUnion>; |
| |
| |
| |
| class NullableUnionStruct final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::std::unique_ptr<::test::union_::Union> the_union; |
| |
| static inline ::std::unique_ptr<NullableUnionStruct> New() { return ::std::make_unique<NullableUnionStruct>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, NullableUnionStruct* value, size_t _offset); |
| zx_status_t Clone(NullableUnionStruct* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::NullableUnionStruct& _value, |
| ::test::union_::NullableUnionStruct* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using NullableUnionStructPtr = ::std::unique_ptr<NullableUnionStruct>; |
| |
| |
| |
| class FlexibleFoo final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| FlexibleFoo(); |
| ~FlexibleFoo(); |
| |
| FlexibleFoo(FlexibleFoo&&); |
| FlexibleFoo& operator=(FlexibleFoo&&); |
| |
| |
| static FlexibleFoo WithS(::std::string&&); |
| static FlexibleFoo WithI(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kS = 1, // 0x1 |
| kI = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<FlexibleFoo> New() { return ::std::make_unique<FlexibleFoo>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, FlexibleFoo* value, size_t offset); |
| zx_status_t Clone(FlexibleFoo* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_s() const { return tag_ == ::test::union_::FlexibleFoo::Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(::test::union_::FlexibleFoo::Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| FlexibleFoo& set_s(::std::string value); |
| |
| bool is_i() const { return tag_ == ::test::union_::FlexibleFoo::Tag::kI; } |
| |
| int32_t& i() { |
| EnsureStorageInitialized(::test::union_::FlexibleFoo::Tag::kI); |
| return i_; |
| } |
| |
| const int32_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| FlexibleFoo& set_i(int32_t value); |
| FlexibleFoo& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::FlexibleFoo::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::FlexibleFoo::Tag::Invalid: |
| case ::test::union_::FlexibleFoo::Tag::kS: |
| case ::test::union_::FlexibleFoo::Tag::kI: |
| return ::test::union_::FlexibleFoo::Tag(tag_); |
| default: |
| return ::test::union_::FlexibleFoo::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::FlexibleFoo::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::FlexibleFoo>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleFoo::Tag::Invalid); |
| union { |
| ::std::string s_; |
| int32_t i_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FlexibleFoo& value, |
| ::test::union_::FlexibleFoo* result) { |
| return value.Clone(result); |
| } |
| |
| using FlexibleFooPtr = ::std::unique_ptr<FlexibleFoo>; |
| |
| |
| |
| class StrictFoo final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| StrictFoo(); |
| ~StrictFoo(); |
| |
| StrictFoo(StrictFoo&&); |
| StrictFoo& operator=(StrictFoo&&); |
| |
| |
| static StrictFoo WithS(::std::string&&); |
| static StrictFoo WithI(int32_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kS = 1, // 0x1 |
| kI = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<StrictFoo> New() { return ::std::make_unique<StrictFoo>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, StrictFoo* value, size_t offset); |
| zx_status_t Clone(StrictFoo* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_s() const { return tag_ == ::test::union_::StrictFoo::Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(::test::union_::StrictFoo::Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| StrictFoo& set_s(::std::string value); |
| |
| bool is_i() const { return tag_ == ::test::union_::StrictFoo::Tag::kI; } |
| |
| int32_t& i() { |
| EnsureStorageInitialized(::test::union_::StrictFoo::Tag::kI); |
| return i_; |
| } |
| |
| const int32_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| StrictFoo& set_i(int32_t value); |
| |
| ::test::union_::StrictFoo::Tag Which() const { |
| |
| return ::test::union_::StrictFoo::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::StrictFoo>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictFoo::Tag::Invalid); |
| union { |
| ::std::string s_; |
| int32_t i_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictFoo& value, |
| ::test::union_::StrictFoo* result) { |
| return value.Clone(result); |
| } |
| |
| using StrictFooPtr = ::std::unique_ptr<StrictFoo>; |
| |
| |
| |
| class ExplicitFoo final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ExplicitFoo(); |
| ~ExplicitFoo(); |
| |
| ExplicitFoo(ExplicitFoo&&); |
| ExplicitFoo& operator=(ExplicitFoo&&); |
| |
| |
| static ExplicitFoo WithI(int32_t&&); |
| static ExplicitFoo WithS(::std::string&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kI = 1, // 0x1 |
| kS = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ExplicitFoo> New() { return ::std::make_unique<ExplicitFoo>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ExplicitFoo* value, size_t offset); |
| zx_status_t Clone(ExplicitFoo* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_i() const { return tag_ == ::test::union_::ExplicitFoo::Tag::kI; } |
| |
| int32_t& i() { |
| EnsureStorageInitialized(::test::union_::ExplicitFoo::Tag::kI); |
| return i_; |
| } |
| |
| const int32_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| ExplicitFoo& set_i(int32_t value); |
| |
| bool is_s() const { return tag_ == ::test::union_::ExplicitFoo::Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(::test::union_::ExplicitFoo::Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| ExplicitFoo& set_s(::std::string value); |
| ExplicitFoo& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::ExplicitFoo::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::ExplicitFoo::Tag::Invalid: |
| case ::test::union_::ExplicitFoo::Tag::kI: |
| case ::test::union_::ExplicitFoo::Tag::kS: |
| return ::test::union_::ExplicitFoo::Tag(tag_); |
| default: |
| return ::test::union_::ExplicitFoo::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::ExplicitFoo::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::ExplicitFoo>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFoo::Tag::Invalid); |
| union { |
| int32_t i_; |
| ::std::string s_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitFoo& value, |
| ::test::union_::ExplicitFoo* result) { |
| return value.Clone(result); |
| } |
| |
| using ExplicitFooPtr = ::std::unique_ptr<ExplicitFoo>; |
| |
| |
| |
| class ExplicitStrictFoo final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ExplicitStrictFoo(); |
| ~ExplicitStrictFoo(); |
| |
| ExplicitStrictFoo(ExplicitStrictFoo&&); |
| ExplicitStrictFoo& operator=(ExplicitStrictFoo&&); |
| |
| |
| static ExplicitStrictFoo WithI(int32_t&&); |
| static ExplicitStrictFoo WithS(::std::string&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kI = 2, // 0x2 |
| kS = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ExplicitStrictFoo> New() { return ::std::make_unique<ExplicitStrictFoo>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ExplicitStrictFoo* value, size_t offset); |
| zx_status_t Clone(ExplicitStrictFoo* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_i() const { return tag_ == ::test::union_::ExplicitStrictFoo::Tag::kI; } |
| |
| int32_t& i() { |
| EnsureStorageInitialized(::test::union_::ExplicitStrictFoo::Tag::kI); |
| return i_; |
| } |
| |
| const int32_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| ExplicitStrictFoo& set_i(int32_t value); |
| |
| bool is_s() const { return tag_ == ::test::union_::ExplicitStrictFoo::Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(::test::union_::ExplicitStrictFoo::Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| ExplicitStrictFoo& set_s(::std::string value); |
| |
| ::test::union_::ExplicitStrictFoo::Tag Which() const { |
| |
| return ::test::union_::ExplicitStrictFoo::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::ExplicitStrictFoo>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitStrictFoo::Tag::Invalid); |
| union { |
| int32_t i_; |
| ::std::string s_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitStrictFoo& value, |
| ::test::union_::ExplicitStrictFoo* result) { |
| return value.Clone(result); |
| } |
| |
| using ExplicitStrictFooPtr = ::std::unique_ptr<ExplicitStrictFoo>; |
| |
| |
| |
| class OlderSimpleUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| OlderSimpleUnion(); |
| ~OlderSimpleUnion(); |
| |
| OlderSimpleUnion(OlderSimpleUnion&&); |
| OlderSimpleUnion& operator=(OlderSimpleUnion&&); |
| |
| |
| static OlderSimpleUnion WithI(int64_t&&); |
| static OlderSimpleUnion WithF(float&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kI = 1, // 0x1 |
| kF = 2, // 0x2 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<OlderSimpleUnion> New() { return ::std::make_unique<OlderSimpleUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, OlderSimpleUnion* value, size_t offset); |
| zx_status_t Clone(OlderSimpleUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_i() const { return tag_ == ::test::union_::OlderSimpleUnion::Tag::kI; } |
| |
| int64_t& i() { |
| EnsureStorageInitialized(::test::union_::OlderSimpleUnion::Tag::kI); |
| return i_; |
| } |
| |
| const int64_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| OlderSimpleUnion& set_i(int64_t value); |
| |
| bool is_f() const { return tag_ == ::test::union_::OlderSimpleUnion::Tag::kF; } |
| |
| float& f() { |
| EnsureStorageInitialized(::test::union_::OlderSimpleUnion::Tag::kF); |
| return f_; |
| } |
| |
| const float& f() const { |
| ZX_ASSERT(is_f()); |
| return f_; |
| } |
| OlderSimpleUnion& set_f(float value); |
| OlderSimpleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::OlderSimpleUnion::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::OlderSimpleUnion::Tag::Invalid: |
| case ::test::union_::OlderSimpleUnion::Tag::kI: |
| case ::test::union_::OlderSimpleUnion::Tag::kF: |
| return ::test::union_::OlderSimpleUnion::Tag(tag_); |
| default: |
| return ::test::union_::OlderSimpleUnion::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::OlderSimpleUnion::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::OlderSimpleUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::OlderSimpleUnion::Tag::Invalid); |
| union { |
| int64_t i_; |
| float f_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::OlderSimpleUnion& value, |
| ::test::union_::OlderSimpleUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using OlderSimpleUnionPtr = ::std::unique_ptr<OlderSimpleUnion>; |
| |
| |
| |
| class NewerSimpleUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| NewerSimpleUnion(); |
| ~NewerSimpleUnion(); |
| |
| NewerSimpleUnion(NewerSimpleUnion&&); |
| NewerSimpleUnion& operator=(NewerSimpleUnion&&); |
| |
| |
| static NewerSimpleUnion WithI(int64_t&&); |
| static NewerSimpleUnion WithS(::std::string&&); |
| static NewerSimpleUnion WithV(::std::vector<::std::string>&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kI = 1, // 0x1 |
| kS = 2, // 0x2 |
| kV = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<NewerSimpleUnion> New() { return ::std::make_unique<NewerSimpleUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, NewerSimpleUnion* value, size_t offset); |
| zx_status_t Clone(NewerSimpleUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_i() const { return tag_ == ::test::union_::NewerSimpleUnion::Tag::kI; } |
| |
| int64_t& i() { |
| EnsureStorageInitialized(::test::union_::NewerSimpleUnion::Tag::kI); |
| return i_; |
| } |
| |
| const int64_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| NewerSimpleUnion& set_i(int64_t value); |
| |
| bool is_s() const { return tag_ == ::test::union_::NewerSimpleUnion::Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(::test::union_::NewerSimpleUnion::Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| NewerSimpleUnion& set_s(::std::string value); |
| |
| bool is_v() const { return tag_ == ::test::union_::NewerSimpleUnion::Tag::kV; } |
| |
| ::std::vector<::std::string>& v() { |
| EnsureStorageInitialized(::test::union_::NewerSimpleUnion::Tag::kV); |
| return v_; |
| } |
| |
| const ::std::vector<::std::string>& v() const { |
| ZX_ASSERT(is_v()); |
| return v_; |
| } |
| NewerSimpleUnion& set_v(::std::vector<::std::string> value); |
| NewerSimpleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::NewerSimpleUnion::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::NewerSimpleUnion::Tag::Invalid: |
| case ::test::union_::NewerSimpleUnion::Tag::kI: |
| case ::test::union_::NewerSimpleUnion::Tag::kS: |
| case ::test::union_::NewerSimpleUnion::Tag::kV: |
| return ::test::union_::NewerSimpleUnion::Tag(tag_); |
| default: |
| return ::test::union_::NewerSimpleUnion::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::NewerSimpleUnion::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::NewerSimpleUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::NewerSimpleUnion::Tag::Invalid); |
| union { |
| int64_t i_; |
| ::std::string s_; |
| ::std::vector<::std::string> v_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::NewerSimpleUnion& value, |
| ::test::union_::NewerSimpleUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using NewerSimpleUnionPtr = ::std::unique_ptr<NewerSimpleUnion>; |
| |
| |
| |
| class StrictSimpleUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| StrictSimpleUnion(); |
| ~StrictSimpleUnion(); |
| |
| StrictSimpleUnion(StrictSimpleUnion&&); |
| StrictSimpleUnion& operator=(StrictSimpleUnion&&); |
| |
| |
| static StrictSimpleUnion WithI(int32_t&&); |
| static StrictSimpleUnion WithF(float&&); |
| static StrictSimpleUnion WithS(::std::string&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kI = 1, // 0x1 |
| kF = 2, // 0x2 |
| kS = 3, // 0x3 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<StrictSimpleUnion> New() { return ::std::make_unique<StrictSimpleUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, StrictSimpleUnion* value, size_t offset); |
| zx_status_t Clone(StrictSimpleUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_i() const { return tag_ == ::test::union_::StrictSimpleUnion::Tag::kI; } |
| |
| int32_t& i() { |
| EnsureStorageInitialized(::test::union_::StrictSimpleUnion::Tag::kI); |
| return i_; |
| } |
| |
| const int32_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| StrictSimpleUnion& set_i(int32_t value); |
| |
| bool is_f() const { return tag_ == ::test::union_::StrictSimpleUnion::Tag::kF; } |
| |
| float& f() { |
| EnsureStorageInitialized(::test::union_::StrictSimpleUnion::Tag::kF); |
| return f_; |
| } |
| |
| const float& f() const { |
| ZX_ASSERT(is_f()); |
| return f_; |
| } |
| StrictSimpleUnion& set_f(float value); |
| |
| bool is_s() const { return tag_ == ::test::union_::StrictSimpleUnion::Tag::kS; } |
| |
| ::std::string& s() { |
| EnsureStorageInitialized(::test::union_::StrictSimpleUnion::Tag::kS); |
| return s_; |
| } |
| |
| const ::std::string& s() const { |
| ZX_ASSERT(is_s()); |
| return s_; |
| } |
| StrictSimpleUnion& set_s(::std::string value); |
| |
| ::test::union_::StrictSimpleUnion::Tag Which() const { |
| |
| return ::test::union_::StrictSimpleUnion::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::StrictSimpleUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictSimpleUnion::Tag::Invalid); |
| union { |
| int32_t i_; |
| float f_; |
| ::std::string s_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictSimpleUnion& value, |
| ::test::union_::StrictSimpleUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using StrictSimpleUnionPtr = ::std::unique_ptr<StrictSimpleUnion>; |
| |
| |
| |
| class Empty final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| uint8_t __reserved= 0u; |
| |
| static inline ::std::unique_ptr<Empty> New() { return ::std::make_unique<Empty>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, Empty* value, size_t _offset); |
| zx_status_t Clone(Empty* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::Empty& _value, |
| ::test::union_::Empty* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using EmptyPtr = ::std::unique_ptr<Empty>; |
| |
| |
| |
| class UnionContainingEmptyStruct final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnionContainingEmptyStruct(); |
| ~UnionContainingEmptyStruct(); |
| |
| UnionContainingEmptyStruct(UnionContainingEmptyStruct&&); |
| UnionContainingEmptyStruct& operator=(UnionContainingEmptyStruct&&); |
| |
| |
| static UnionContainingEmptyStruct WithEmpty(::test::union_::Empty&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kEmpty = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnionContainingEmptyStruct> New() { return ::std::make_unique<UnionContainingEmptyStruct>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnionContainingEmptyStruct* value, size_t offset); |
| zx_status_t Clone(UnionContainingEmptyStruct* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_empty() const { return tag_ == ::test::union_::UnionContainingEmptyStruct::Tag::kEmpty; } |
| |
| ::test::union_::Empty& empty() { |
| EnsureStorageInitialized(::test::union_::UnionContainingEmptyStruct::Tag::kEmpty); |
| return empty_; |
| } |
| |
| const ::test::union_::Empty& empty() const { |
| ZX_ASSERT(is_empty()); |
| return empty_; |
| } |
| UnionContainingEmptyStruct& set_empty(::test::union_::Empty value); |
| UnionContainingEmptyStruct& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::UnionContainingEmptyStruct::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::UnionContainingEmptyStruct::Tag::Invalid: |
| case ::test::union_::UnionContainingEmptyStruct::Tag::kEmpty: |
| return ::test::union_::UnionContainingEmptyStruct::Tag(tag_); |
| default: |
| return ::test::union_::UnionContainingEmptyStruct::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::UnionContainingEmptyStruct::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::UnionContainingEmptyStruct>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::UnionContainingEmptyStruct::Tag::Invalid); |
| union { |
| ::test::union_::Empty empty_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::UnionContainingEmptyStruct& value, |
| ::test::union_::UnionContainingEmptyStruct* result) { |
| return value.Clone(result); |
| } |
| |
| using UnionContainingEmptyStructPtr = ::std::unique_ptr<UnionContainingEmptyStruct>; |
| |
| |
| |
| class StrictBoundedUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| StrictBoundedUnion(); |
| ~StrictBoundedUnion(); |
| |
| StrictBoundedUnion(StrictBoundedUnion&&); |
| StrictBoundedUnion& operator=(StrictBoundedUnion&&); |
| |
| |
| static StrictBoundedUnion WithV(::std::vector<uint8_t>&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| |
| kV = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<StrictBoundedUnion> New() { return ::std::make_unique<StrictBoundedUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, StrictBoundedUnion* value, size_t offset); |
| zx_status_t Clone(StrictBoundedUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_v() const { return tag_ == ::test::union_::StrictBoundedUnion::Tag::kV; } |
| |
| ::std::vector<uint8_t>& v() { |
| EnsureStorageInitialized(::test::union_::StrictBoundedUnion::Tag::kV); |
| return v_; |
| } |
| |
| const ::std::vector<uint8_t>& v() const { |
| ZX_ASSERT(is_v()); |
| return v_; |
| } |
| StrictBoundedUnion& set_v(::std::vector<uint8_t> value); |
| |
| ::test::union_::StrictBoundedUnion::Tag Which() const { |
| |
| return ::test::union_::StrictBoundedUnion::Tag(tag_); |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::StrictBoundedUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::StrictBoundedUnion::Tag::Invalid); |
| union { |
| ::std::vector<uint8_t> v_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictBoundedUnion& value, |
| ::test::union_::StrictBoundedUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using StrictBoundedUnionPtr = ::std::unique_ptr<StrictBoundedUnion>; |
| |
| |
| |
| class TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::union_::StrictBoundedUnion xu; |
| |
| static inline ::std::unique_ptr<TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> New() { return ::std::make_unique<TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* value, size_t _offset); |
| zx_status_t Clone(TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& _value, |
| ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponsePtr = ::std::unique_ptr<TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse>; |
| |
| |
| |
| class TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::test::union_::OlderSimpleUnion xu; |
| |
| static inline ::std::unique_ptr<TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse> New() { return ::std::make_unique<TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* value, size_t _offset); |
| zx_status_t Clone(TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& _value, |
| ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponsePtr = ::std::unique_ptr<TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse>; |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| class TestProtocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictUnionHenceResponseMayBeStackAllocated(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleUnionHenceResponseMustBeHeapAllocated(::fidl::MessageEncoder* _encoder) { |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| namespace _internal { |
| __LOCAL extern "C" const fidl_type_t test_union_TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t test_union_TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponseTable; |
| |
| } // namespace _internal |
| |
| class TestProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage StrictUnionHenceResponseMayBeStackAllocated(::fidl::MessageEncoder* _encoder, ::test::union_::StrictBoundedUnion* xu) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, xu, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage FlexibleUnionHenceResponseMustBeHeapAllocated(::fidl::MessageEncoder* _encoder, ::test::union_::OlderSimpleUnion* xu) { |
| _encoder->Alloc(16); |
| ::fidl::Encode(_encoder, xu, 0 + sizeof(fidl_message_header_t)); |
| |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| class StructWithNullableUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ::std::unique_ptr<::test::union_::OlderSimpleUnion> x1; |
| |
| static inline ::std::unique_ptr<StructWithNullableUnion> New() { return ::std::make_unique<StructWithNullableUnion>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, StructWithNullableUnion* value, size_t _offset); |
| zx_status_t Clone(StructWithNullableUnion* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StructWithNullableUnion& _value, |
| ::test::union_::StructWithNullableUnion* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using StructWithNullableUnionPtr = ::std::unique_ptr<StructWithNullableUnion>; |
| |
| |
| |
| class ExplicitFlexibleUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| ExplicitFlexibleUnion(); |
| ~ExplicitFlexibleUnion(); |
| |
| ExplicitFlexibleUnion(ExplicitFlexibleUnion&&); |
| ExplicitFlexibleUnion& operator=(ExplicitFlexibleUnion&&); |
| |
| |
| static ExplicitFlexibleUnion WithI(int64_t&&); |
| static ExplicitFlexibleUnion WithF(float&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kI = 1, // 0x1 |
| kF = 4, // 0x4 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<ExplicitFlexibleUnion> New() { return ::std::make_unique<ExplicitFlexibleUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, ExplicitFlexibleUnion* value, size_t offset); |
| zx_status_t Clone(ExplicitFlexibleUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_i() const { return tag_ == ::test::union_::ExplicitFlexibleUnion::Tag::kI; } |
| |
| int64_t& i() { |
| EnsureStorageInitialized(::test::union_::ExplicitFlexibleUnion::Tag::kI); |
| return i_; |
| } |
| |
| const int64_t& i() const { |
| ZX_ASSERT(is_i()); |
| return i_; |
| } |
| ExplicitFlexibleUnion& set_i(int64_t value); |
| |
| bool is_f() const { return tag_ == ::test::union_::ExplicitFlexibleUnion::Tag::kF; } |
| |
| float& f() { |
| EnsureStorageInitialized(::test::union_::ExplicitFlexibleUnion::Tag::kF); |
| return f_; |
| } |
| |
| const float& f() const { |
| ZX_ASSERT(is_f()); |
| return f_; |
| } |
| ExplicitFlexibleUnion& set_f(float value); |
| ExplicitFlexibleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::ExplicitFlexibleUnion::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::ExplicitFlexibleUnion::Tag::Invalid: |
| case ::test::union_::ExplicitFlexibleUnion::Tag::kI: |
| case ::test::union_::ExplicitFlexibleUnion::Tag::kF: |
| return ::test::union_::ExplicitFlexibleUnion::Tag(tag_); |
| default: |
| return ::test::union_::ExplicitFlexibleUnion::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::ExplicitFlexibleUnion::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::ExplicitFlexibleUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFlexibleUnion::Tag::Invalid); |
| union { |
| int64_t i_; |
| float f_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitFlexibleUnion& value, |
| ::test::union_::ExplicitFlexibleUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using ExplicitFlexibleUnionPtr = ::std::unique_ptr<ExplicitFlexibleUnion>; |
| |
| |
| |
| class UnionSandwich final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| uint32_t a{}; |
| |
| ::test::union_::ExplicitFlexibleUnion u; |
| |
| uint32_t b{}; |
| |
| static inline ::std::unique_ptr<UnionSandwich> New() { return ::std::make_unique<UnionSandwich>(); } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnionSandwich* value, size_t _offset); |
| zx_status_t Clone(UnionSandwich* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::UnionSandwich& _value, |
| ::test::union_::UnionSandwich* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using UnionSandwichPtr = ::std::unique_ptr<UnionSandwich>; |
| |
| |
| |
| class UnionWithAttributes final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| UnionWithAttributes(); |
| ~UnionWithAttributes(); |
| |
| UnionWithAttributes(UnionWithAttributes&&); |
| UnionWithAttributes& operator=(UnionWithAttributes&&); |
| |
| |
| static UnionWithAttributes WithX(int64_t&&); |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| kX = 1, // 0x1 |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<UnionWithAttributes> New() { return ::std::make_unique<UnionWithAttributes>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, UnionWithAttributes* value, size_t offset); |
| zx_status_t Clone(UnionWithAttributes* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| |
| bool is_x() const { return tag_ == ::test::union_::UnionWithAttributes::Tag::kX; } |
| |
| int64_t& x() { |
| EnsureStorageInitialized(::test::union_::UnionWithAttributes::Tag::kX); |
| return x_; |
| } |
| |
| const int64_t& x() const { |
| ZX_ASSERT(is_x()); |
| return x_; |
| } |
| UnionWithAttributes& set_x(int64_t value); |
| UnionWithAttributes& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::UnionWithAttributes::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::UnionWithAttributes::Tag::Invalid: |
| case ::test::union_::UnionWithAttributes::Tag::kX: |
| return ::test::union_::UnionWithAttributes::Tag(tag_); |
| default: |
| return ::test::union_::UnionWithAttributes::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::UnionWithAttributes::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::UnionWithAttributes>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::UnionWithAttributes::Tag::Invalid); |
| union { |
| int64_t x_; |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::UnionWithAttributes& value, |
| ::test::union_::UnionWithAttributes* result) { |
| return value.Clone(result); |
| } |
| |
| using UnionWithAttributesPtr = ::std::unique_ptr<UnionWithAttributes>; |
| |
| |
| |
| class EmptyFlexibleUnion final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| EmptyFlexibleUnion(); |
| ~EmptyFlexibleUnion(); |
| |
| EmptyFlexibleUnion(EmptyFlexibleUnion&&); |
| EmptyFlexibleUnion& operator=(EmptyFlexibleUnion&&); |
| |
| |
| |
| enum __attribute__((enum_extensibility(closed))) Tag : fidl_xunion_tag_t { |
| kUnknown = 0, |
| |
| Invalid = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| |
| static inline ::std::unique_ptr<EmptyFlexibleUnion> New() { return ::std::make_unique<EmptyFlexibleUnion>(); } |
| |
| void Encode(::fidl::Encoder* encoder, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, EmptyFlexibleUnion* value, size_t offset); |
| zx_status_t Clone(EmptyFlexibleUnion* result) const; |
| |
| bool has_invalid_tag() const { |
| return tag_ == Invalid; |
| } |
| EmptyFlexibleUnion& SetUnknownData(fidl_xunion_tag_t ordinal, std::vector<uint8_t> bytes); |
| |
| ::test::union_::EmptyFlexibleUnion::Tag Which() const { |
| |
| switch (tag_) { |
| case ::test::union_::EmptyFlexibleUnion::Tag::Invalid: |
| return ::test::union_::EmptyFlexibleUnion::Tag(tag_); |
| default: |
| return ::test::union_::EmptyFlexibleUnion::Tag::kUnknown; |
| } |
| |
| } |
| |
| // You probably want to use Which() method instead of Ordinal(). Use Ordinal() only when you need |
| // access to the raw integral ordinal value. |
| fidl_xunion_tag_t Ordinal() const { |
| return tag_; |
| } |
| const std::vector<uint8_t>* UnknownBytes() const { |
| if (Which() != ::test::union_::EmptyFlexibleUnion::Tag::kUnknown) { |
| return nullptr; |
| } |
| return &unknown_data_; |
| } |
| |
| friend ::fidl::Equality<::test::union_::EmptyFlexibleUnion>; |
| |
| private: |
| void Destroy(); |
| void EnsureStorageInitialized(::fidl_xunion_tag_t tag); |
| |
| ::fidl_xunion_tag_t tag_ = static_cast<fidl_xunion_tag_t>(::test::union_::EmptyFlexibleUnion::Tag::Invalid); |
| union { |
| std::vector<uint8_t> unknown_data_; |
| }; |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::EmptyFlexibleUnion& value, |
| ::test::union_::EmptyFlexibleUnion* result) { |
| return value.Clone(result); |
| } |
| |
| using EmptyFlexibleUnionPtr = ::std::unique_ptr<EmptyFlexibleUnion>; |
| |
| |
| } // namespace union_ |
| } // namespace test |
| namespace fidl { |
| |
| template <> |
| struct CodingTraits<::test::union_::Pizza> |
| : public EncodableCodingTraits<::test::union_::Pizza, 16> {}; |
| |
| |
| template<> |
| struct HasPadding<::test::union_::Pizza> : public std::true_type {}; |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::Pizza> : public internal::BoolConstant< |
| !HasPadding<::test::union_::Pizza>::value |
| && IsMemcpyCompatible<::std::vector<::std::string>>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::Pizza& value, |
| ::test::union_::Pizza* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::Pizza> { |
| bool operator()(const ::test::union_::Pizza& _lhs, const ::test::union_::Pizza& _rhs) const { |
| if (!::fidl::Equals(_lhs.toppings, _rhs.toppings)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::union_::Pasta> |
| : public EncodableCodingTraits<::test::union_::Pasta, 16> {}; |
| |
| |
| template<> |
| struct HasPadding<::test::union_::Pasta> : public std::true_type {}; |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::Pasta> : public internal::BoolConstant< |
| !HasPadding<::test::union_::Pasta>::value |
| && IsMemcpyCompatible<::std::string>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::Pasta& value, |
| ::test::union_::Pasta* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::Pasta> { |
| bool operator()(const ::test::union_::Pasta& _lhs, const ::test::union_::Pasta& _rhs) const { |
| if (!::fidl::Equals(_lhs.sauce, _rhs.sauce)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::PizzaOrPasta> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::PizzaOrPasta> |
| : public EncodableCodingTraits<::test::union_::PizzaOrPasta, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::PizzaOrPasta>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::PizzaOrPasta>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::PizzaOrPasta>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::PizzaOrPasta); |
| |
| ::test::union_::PizzaOrPasta::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::PizzaOrPasta& value, |
| ::test::union_::PizzaOrPasta* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::PizzaOrPasta> { |
| bool operator()(const ::test::union_::PizzaOrPasta& _lhs, const ::test::union_::PizzaOrPasta& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::PizzaOrPasta::Tag::Invalid): |
| return true; |
| case ::test::union_::PizzaOrPasta::Tag::kPizza: |
| return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_); |
| case ::test::union_::PizzaOrPasta::Tag::kPasta: |
| return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::ExplicitPizzaOrPasta> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::ExplicitPizzaOrPasta> |
| : public EncodableCodingTraits<::test::union_::ExplicitPizzaOrPasta, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::ExplicitPizzaOrPasta>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitPizzaOrPasta>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitPizzaOrPasta>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::ExplicitPizzaOrPasta); |
| |
| ::test::union_::ExplicitPizzaOrPasta::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitPizzaOrPasta& value, |
| ::test::union_::ExplicitPizzaOrPasta* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::ExplicitPizzaOrPasta> { |
| bool operator()(const ::test::union_::ExplicitPizzaOrPasta& _lhs, const ::test::union_::ExplicitPizzaOrPasta& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitPizzaOrPasta::Tag::Invalid): |
| return true; |
| case ::test::union_::ExplicitPizzaOrPasta::Tag::kPizza: |
| return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_); |
| case ::test::union_::ExplicitPizzaOrPasta::Tag::kPasta: |
| return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::FlexiblePizzaOrPasta> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::FlexiblePizzaOrPasta> |
| : public EncodableCodingTraits<::test::union_::FlexiblePizzaOrPasta, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::FlexiblePizzaOrPasta>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FlexiblePizzaOrPasta>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FlexiblePizzaOrPasta>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::FlexiblePizzaOrPasta); |
| |
| ::test::union_::FlexiblePizzaOrPasta::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FlexiblePizzaOrPasta& value, |
| ::test::union_::FlexiblePizzaOrPasta* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::FlexiblePizzaOrPasta> { |
| bool operator()(const ::test::union_::FlexiblePizzaOrPasta& _lhs, const ::test::union_::FlexiblePizzaOrPasta& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::FlexiblePizzaOrPasta::Tag::Invalid): |
| return true; |
| case ::test::union_::FlexiblePizzaOrPasta::Tag::kPizza: |
| return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_); |
| case ::test::union_::FlexiblePizzaOrPasta::Tag::kPasta: |
| return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::StrictPizzaOrPasta> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::StrictPizzaOrPasta> |
| : public EncodableCodingTraits<::test::union_::StrictPizzaOrPasta, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::StrictPizzaOrPasta>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictPizzaOrPasta>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictPizzaOrPasta>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::StrictPizzaOrPasta); |
| |
| ::test::union_::StrictPizzaOrPasta::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictPizzaOrPasta& value, |
| ::test::union_::StrictPizzaOrPasta* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::StrictPizzaOrPasta> { |
| bool operator()(const ::test::union_::StrictPizzaOrPasta& _lhs, const ::test::union_::StrictPizzaOrPasta& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::StrictPizzaOrPasta::Tag::Invalid): |
| return true; |
| case ::test::union_::StrictPizzaOrPasta::Tag::kPizza: |
| return ::fidl::Equals(_lhs.pizza_, _rhs.pizza_); |
| case ::test::union_::StrictPizzaOrPasta::Tag::kPasta: |
| return ::fidl::Equals(_lhs.pasta_, _rhs.pasta_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::Union> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::Union> |
| : public EncodableCodingTraits<::test::union_::Union, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::Union>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::Union>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::Union>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::Union); |
| |
| ::test::union_::Union::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::Union& value, |
| ::test::union_::Union* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::Union> { |
| bool operator()(const ::test::union_::Union& _lhs, const ::test::union_::Union& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::Union::Tag::Invalid): |
| return true; |
| case ::test::union_::Union::Tag::kPrimitive: |
| return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_); |
| case ::test::union_::Union::Tag::kStringNeedsConstructor: |
| return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_); |
| case ::test::union_::Union::Tag::kVectorStringAlsoNeedsConstructor: |
| return ::fidl::Equals(_lhs.VectorStringAlsoNeedsConstructor_, _rhs.VectorStringAlsoNeedsConstructor_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::FlexibleUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::FlexibleUnion> |
| : public EncodableCodingTraits<::test::union_::FlexibleUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::FlexibleUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FlexibleUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FlexibleUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::FlexibleUnion); |
| |
| ::test::union_::FlexibleUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FlexibleUnion& value, |
| ::test::union_::FlexibleUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::FlexibleUnion> { |
| bool operator()(const ::test::union_::FlexibleUnion& _lhs, const ::test::union_::FlexibleUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::FlexibleUnion::Tag::kPrimitive: |
| return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_); |
| case ::test::union_::FlexibleUnion::Tag::kStringNeedsConstructor: |
| return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_); |
| case ::test::union_::FlexibleUnion::Tag::kVectorStringAlsoNeedsConstructor: |
| return ::fidl::Equals(_lhs.VectorStringAlsoNeedsConstructor_, _rhs.VectorStringAlsoNeedsConstructor_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::StrictUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::StrictUnion> |
| : public EncodableCodingTraits<::test::union_::StrictUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::StrictUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::StrictUnion); |
| |
| ::test::union_::StrictUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictUnion& value, |
| ::test::union_::StrictUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::StrictUnion> { |
| bool operator()(const ::test::union_::StrictUnion& _lhs, const ::test::union_::StrictUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::StrictUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::StrictUnion::Tag::kPrimitive: |
| return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_); |
| case ::test::union_::StrictUnion::Tag::kStringNeedsConstructor: |
| return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_); |
| case ::test::union_::StrictUnion::Tag::kVectorStringAlsoNeedsConstructor: |
| return ::fidl::Equals(_lhs.VectorStringAlsoNeedsConstructor_, _rhs.VectorStringAlsoNeedsConstructor_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::FieldCollision> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::FieldCollision> |
| : public EncodableCodingTraits<::test::union_::FieldCollision, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::FieldCollision>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FieldCollision>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FieldCollision>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::FieldCollision); |
| |
| ::test::union_::FieldCollision::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FieldCollision& value, |
| ::test::union_::FieldCollision* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::FieldCollision> { |
| bool operator()(const ::test::union_::FieldCollision& _lhs, const ::test::union_::FieldCollision& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::FieldCollision::Tag::Invalid): |
| return true; |
| case ::test::union_::FieldCollision::Tag::kFieldCollisionTag: |
| return ::fidl::Equals(_lhs.field_collision_tag_, _rhs.field_collision_tag_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::ExplicitUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::ExplicitUnion> |
| : public EncodableCodingTraits<::test::union_::ExplicitUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::ExplicitUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::ExplicitUnion); |
| |
| ::test::union_::ExplicitUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitUnion& value, |
| ::test::union_::ExplicitUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::ExplicitUnion> { |
| bool operator()(const ::test::union_::ExplicitUnion& _lhs, const ::test::union_::ExplicitUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::ExplicitUnion::Tag::kPrimitive: |
| return ::fidl::Equals(_lhs.Primitive_, _rhs.Primitive_); |
| case ::test::union_::ExplicitUnion::Tag::kStringNeedsConstructor: |
| return ::fidl::Equals(_lhs.StringNeedsConstructor_, _rhs.StringNeedsConstructor_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::ReverseOrdinalUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::ReverseOrdinalUnion> |
| : public EncodableCodingTraits<::test::union_::ReverseOrdinalUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::ReverseOrdinalUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ReverseOrdinalUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ReverseOrdinalUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::ReverseOrdinalUnion); |
| |
| ::test::union_::ReverseOrdinalUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ReverseOrdinalUnion& value, |
| ::test::union_::ReverseOrdinalUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::ReverseOrdinalUnion> { |
| bool operator()(const ::test::union_::ReverseOrdinalUnion& _lhs, const ::test::union_::ReverseOrdinalUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::ReverseOrdinalUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::ReverseOrdinalUnion::Tag::kFirst: |
| return ::fidl::Equals(_lhs.first_, _rhs.first_); |
| case ::test::union_::ReverseOrdinalUnion::Tag::kSecond: |
| return ::fidl::Equals(_lhs.second_, _rhs.second_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::union_::NullableUnionStruct> |
| : public EncodableCodingTraits<::test::union_::NullableUnionStruct, 16> {}; |
| |
| |
| template<> |
| struct HasPadding<::test::union_::NullableUnionStruct> : public std::true_type {}; |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::NullableUnionStruct> : public internal::BoolConstant< |
| !HasPadding<::test::union_::NullableUnionStruct>::value |
| && IsMemcpyCompatible<::std::unique_ptr<::test::union_::Union>>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::NullableUnionStruct& value, |
| ::test::union_::NullableUnionStruct* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::NullableUnionStruct> { |
| bool operator()(const ::test::union_::NullableUnionStruct& _lhs, const ::test::union_::NullableUnionStruct& _rhs) const { |
| if (!::fidl::Equals(_lhs.the_union, _rhs.the_union)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::FlexibleFoo> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::FlexibleFoo> |
| : public EncodableCodingTraits<::test::union_::FlexibleFoo, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::FlexibleFoo>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::FlexibleFoo>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::FlexibleFoo>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::FlexibleFoo); |
| |
| ::test::union_::FlexibleFoo::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::FlexibleFoo& value, |
| ::test::union_::FlexibleFoo* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::FlexibleFoo> { |
| bool operator()(const ::test::union_::FlexibleFoo& _lhs, const ::test::union_::FlexibleFoo& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::FlexibleFoo::Tag::Invalid): |
| return true; |
| case ::test::union_::FlexibleFoo::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| case ::test::union_::FlexibleFoo::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::StrictFoo> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::StrictFoo> |
| : public EncodableCodingTraits<::test::union_::StrictFoo, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::StrictFoo>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictFoo>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictFoo>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::StrictFoo); |
| |
| ::test::union_::StrictFoo::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictFoo& value, |
| ::test::union_::StrictFoo* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::StrictFoo> { |
| bool operator()(const ::test::union_::StrictFoo& _lhs, const ::test::union_::StrictFoo& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::StrictFoo::Tag::Invalid): |
| return true; |
| case ::test::union_::StrictFoo::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| case ::test::union_::StrictFoo::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::ExplicitFoo> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::ExplicitFoo> |
| : public EncodableCodingTraits<::test::union_::ExplicitFoo, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::ExplicitFoo>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitFoo>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitFoo>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::ExplicitFoo); |
| |
| ::test::union_::ExplicitFoo::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitFoo& value, |
| ::test::union_::ExplicitFoo* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::ExplicitFoo> { |
| bool operator()(const ::test::union_::ExplicitFoo& _lhs, const ::test::union_::ExplicitFoo& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFoo::Tag::Invalid): |
| return true; |
| case ::test::union_::ExplicitFoo::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| case ::test::union_::ExplicitFoo::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::ExplicitStrictFoo> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::ExplicitStrictFoo> |
| : public EncodableCodingTraits<::test::union_::ExplicitStrictFoo, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::ExplicitStrictFoo>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitStrictFoo>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitStrictFoo>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::ExplicitStrictFoo); |
| |
| ::test::union_::ExplicitStrictFoo::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitStrictFoo& value, |
| ::test::union_::ExplicitStrictFoo* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::ExplicitStrictFoo> { |
| bool operator()(const ::test::union_::ExplicitStrictFoo& _lhs, const ::test::union_::ExplicitStrictFoo& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitStrictFoo::Tag::Invalid): |
| return true; |
| case ::test::union_::ExplicitStrictFoo::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| case ::test::union_::ExplicitStrictFoo::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::OlderSimpleUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::OlderSimpleUnion> |
| : public EncodableCodingTraits<::test::union_::OlderSimpleUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::OlderSimpleUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::OlderSimpleUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::OlderSimpleUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::OlderSimpleUnion); |
| |
| ::test::union_::OlderSimpleUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::OlderSimpleUnion& value, |
| ::test::union_::OlderSimpleUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::OlderSimpleUnion> { |
| bool operator()(const ::test::union_::OlderSimpleUnion& _lhs, const ::test::union_::OlderSimpleUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::OlderSimpleUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::OlderSimpleUnion::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| case ::test::union_::OlderSimpleUnion::Tag::kF: |
| return ::fidl::Equals(_lhs.f_, _rhs.f_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::NewerSimpleUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::NewerSimpleUnion> |
| : public EncodableCodingTraits<::test::union_::NewerSimpleUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::NewerSimpleUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::NewerSimpleUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::NewerSimpleUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::NewerSimpleUnion); |
| |
| ::test::union_::NewerSimpleUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::NewerSimpleUnion& value, |
| ::test::union_::NewerSimpleUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::NewerSimpleUnion> { |
| bool operator()(const ::test::union_::NewerSimpleUnion& _lhs, const ::test::union_::NewerSimpleUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::NewerSimpleUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::NewerSimpleUnion::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| case ::test::union_::NewerSimpleUnion::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| case ::test::union_::NewerSimpleUnion::Tag::kV: |
| return ::fidl::Equals(_lhs.v_, _rhs.v_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::StrictSimpleUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::StrictSimpleUnion> |
| : public EncodableCodingTraits<::test::union_::StrictSimpleUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::StrictSimpleUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictSimpleUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictSimpleUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::StrictSimpleUnion); |
| |
| ::test::union_::StrictSimpleUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictSimpleUnion& value, |
| ::test::union_::StrictSimpleUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::StrictSimpleUnion> { |
| bool operator()(const ::test::union_::StrictSimpleUnion& _lhs, const ::test::union_::StrictSimpleUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::StrictSimpleUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::StrictSimpleUnion::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| case ::test::union_::StrictSimpleUnion::Tag::kF: |
| return ::fidl::Equals(_lhs.f_, _rhs.f_); |
| case ::test::union_::StrictSimpleUnion::Tag::kS: |
| return ::fidl::Equals(_lhs.s_, _rhs.s_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::union_::Empty> |
| : public EncodableCodingTraits<::test::union_::Empty, 1> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::Empty> : public internal::BoolConstant< |
| !HasPadding<::test::union_::Empty>::value |
| && IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::Empty& value, |
| ::test::union_::Empty* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::Empty> { |
| bool operator()(const ::test::union_::Empty& _lhs, const ::test::union_::Empty& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::UnionContainingEmptyStruct> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::UnionContainingEmptyStruct> |
| : public EncodableCodingTraits<::test::union_::UnionContainingEmptyStruct, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::UnionContainingEmptyStruct>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::UnionContainingEmptyStruct>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::UnionContainingEmptyStruct>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::UnionContainingEmptyStruct); |
| |
| ::test::union_::UnionContainingEmptyStruct::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::UnionContainingEmptyStruct& value, |
| ::test::union_::UnionContainingEmptyStruct* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::UnionContainingEmptyStruct> { |
| bool operator()(const ::test::union_::UnionContainingEmptyStruct& _lhs, const ::test::union_::UnionContainingEmptyStruct& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::UnionContainingEmptyStruct::Tag::Invalid): |
| return true; |
| case ::test::union_::UnionContainingEmptyStruct::Tag::kEmpty: |
| return ::fidl::Equals(_lhs.empty_, _rhs.empty_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::StrictBoundedUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::StrictBoundedUnion> |
| : public EncodableCodingTraits<::test::union_::StrictBoundedUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::StrictBoundedUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::StrictBoundedUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::StrictBoundedUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::StrictBoundedUnion); |
| |
| ::test::union_::StrictBoundedUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::StrictBoundedUnion& value, |
| ::test::union_::StrictBoundedUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::StrictBoundedUnion> { |
| bool operator()(const ::test::union_::StrictBoundedUnion& _lhs, const ::test::union_::StrictBoundedUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::StrictBoundedUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::StrictBoundedUnion::Tag::kV: |
| return ::fidl::Equals(_lhs.v_, _rhs.v_); |
| |
| default: |
| return false; |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> |
| : public EncodableCodingTraits<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse, 16> {}; |
| |
| |
| template<> |
| struct HasPadding<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> : public std::true_type {}; |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> : public internal::BoolConstant< |
| !HasPadding<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse>::value |
| && IsMemcpyCompatible<::test::union_::StrictBoundedUnion>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& value, |
| ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse> { |
| bool operator()(const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& _lhs, const ::test::union_::TestProtocolStrictUnionHenceResponseMayBeStackAllocatedResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.xu, _rhs.xu)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse> |
| : public EncodableCodingTraits<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse, 16> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse> : public internal::BoolConstant< |
| !HasPadding<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse>::value |
| && IsMemcpyCompatible<::test::union_::OlderSimpleUnion>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& value, |
| ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse> { |
| bool operator()(const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& _lhs, const ::test::union_::TestProtocolFlexibleUnionHenceResponseMustBeHeapAllocatedResponse& _rhs) const { |
| if (!::fidl::Equals(_lhs.xu, _rhs.xu)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::union_::StructWithNullableUnion> |
| : public EncodableCodingTraits<::test::union_::StructWithNullableUnion, 16> {}; |
| |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::StructWithNullableUnion> : public internal::BoolConstant< |
| !HasPadding<::test::union_::StructWithNullableUnion>::value |
| && IsMemcpyCompatible<::std::unique_ptr<::test::union_::OlderSimpleUnion>>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::StructWithNullableUnion& value, |
| ::test::union_::StructWithNullableUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::StructWithNullableUnion> { |
| bool operator()(const ::test::union_::StructWithNullableUnion& _lhs, const ::test::union_::StructWithNullableUnion& _rhs) const { |
| if (!::fidl::Equals(_lhs.x1, _rhs.x1)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::ExplicitFlexibleUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::ExplicitFlexibleUnion> |
| : public EncodableCodingTraits<::test::union_::ExplicitFlexibleUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::ExplicitFlexibleUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::ExplicitFlexibleUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::ExplicitFlexibleUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::ExplicitFlexibleUnion); |
| |
| ::test::union_::ExplicitFlexibleUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::ExplicitFlexibleUnion& value, |
| ::test::union_::ExplicitFlexibleUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::ExplicitFlexibleUnion> { |
| bool operator()(const ::test::union_::ExplicitFlexibleUnion& _lhs, const ::test::union_::ExplicitFlexibleUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::ExplicitFlexibleUnion::Tag::Invalid): |
| return true; |
| case ::test::union_::ExplicitFlexibleUnion::Tag::kI: |
| return ::fidl::Equals(_lhs.i_, _rhs.i_); |
| case ::test::union_::ExplicitFlexibleUnion::Tag::kF: |
| return ::fidl::Equals(_lhs.f_, _rhs.f_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct CodingTraits<::test::union_::UnionSandwich> |
| : public EncodableCodingTraits<::test::union_::UnionSandwich, 32> {}; |
| |
| |
| template<> |
| struct HasPadding<::test::union_::UnionSandwich> : public std::true_type {}; |
| |
| |
| |
| template<> |
| struct IsMemcpyCompatible<::test::union_::UnionSandwich> : public internal::BoolConstant< |
| !HasPadding<::test::union_::UnionSandwich>::value |
| && IsMemcpyCompatible<uint32_t>::value |
| && IsMemcpyCompatible<::test::union_::ExplicitFlexibleUnion>::value> {}; |
| |
| |
| inline zx_status_t Clone(const ::test::union_::UnionSandwich& value, |
| ::test::union_::UnionSandwich* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::UnionSandwich> { |
| bool operator()(const ::test::union_::UnionSandwich& _lhs, const ::test::union_::UnionSandwich& _rhs) const { |
| if (!::fidl::Equals(_lhs.a, _rhs.a)) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.u, _rhs.u)) { |
| return false; |
| } |
| if (!::fidl::Equals(_lhs.b, _rhs.b)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::UnionWithAttributes> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::UnionWithAttributes> |
| : public EncodableCodingTraits<::test::union_::UnionWithAttributes, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::UnionWithAttributes>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::UnionWithAttributes>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::UnionWithAttributes>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::UnionWithAttributes); |
| |
| ::test::union_::UnionWithAttributes::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::UnionWithAttributes& value, |
| ::test::union_::UnionWithAttributes* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::UnionWithAttributes> { |
| bool operator()(const ::test::union_::UnionWithAttributes& _lhs, const ::test::union_::UnionWithAttributes& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::UnionWithAttributes::Tag::Invalid): |
| return true; |
| case ::test::union_::UnionWithAttributes::Tag::kX: |
| return ::fidl::Equals(_lhs.x_, _rhs.x_); |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| template <> |
| struct IsFidlXUnion<::test::union_::EmptyFlexibleUnion> : public std::true_type {}; |
| |
| template <> |
| struct CodingTraits<::test::union_::EmptyFlexibleUnion> |
| : public EncodableCodingTraits<::test::union_::EmptyFlexibleUnion, 16> {}; |
| |
| template <> |
| struct CodingTraits<std::unique_ptr<::test::union_::EmptyFlexibleUnion>> { |
| static constexpr size_t inline_size_v2 = 16; |
| |
| static void Encode(Encoder* encoder, std::unique_ptr<::test::union_::EmptyFlexibleUnion>* value, size_t offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = cpp17::nullopt) { |
| auto&& p_xunion = *value; |
| if (p_xunion) { |
| p_xunion->Encode(encoder, offset); |
| } |
| } |
| |
| static void Decode(Decoder* _decoder, std::unique_ptr<::test::union_::EmptyFlexibleUnion>* value, size_t offset) { |
| fidl_union_t* encoded = _decoder->GetPtr<fidl_union_t>(offset); |
| if (encoded->tag == 0) { |
| value->reset(nullptr); |
| return; |
| } |
| |
| value->reset(new ::test::union_::EmptyFlexibleUnion); |
| |
| ::test::union_::EmptyFlexibleUnion::Decode(_decoder, value->get(), offset); |
| } |
| }; |
| |
| inline zx_status_t Clone(const ::test::union_::EmptyFlexibleUnion& value, |
| ::test::union_::EmptyFlexibleUnion* result) { |
| return ::test::union_::Clone(value, result); |
| } |
| |
| template<> |
| struct Equality<::test::union_::EmptyFlexibleUnion> { |
| bool operator()(const ::test::union_::EmptyFlexibleUnion& _lhs, const ::test::union_::EmptyFlexibleUnion& _rhs) const { |
| if (_lhs.Ordinal() != _rhs.Ordinal()) { |
| return false; |
| } |
| |
| switch (_lhs.Ordinal()) { |
| case static_cast<fidl_xunion_tag_t>(::test::union_::EmptyFlexibleUnion::Tag::Invalid): |
| return true; |
| default: |
| return ::fidl::Equals(_lhs.unknown_data_, _rhs.unknown_data_); |
| } |
| } |
| }; |
| |
| // |
| // Proxies and stubs declarations |
| // |
| } // namespace fidl |
| namespace test { |
| namespace union_ { |
| |
| #ifdef __Fuchsia__ |
| |
| using TestProtocolPtr = ::fidl::InterfacePtr<TestProtocol>; |
| class TestProtocol_Proxy; |
| class TestProtocol_Stub; |
| class TestProtocol_EventSender; |
| class TestProtocol_Sync; |
| using TestProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<TestProtocol>; |
| class TestProtocol_SyncProxy; |
| |
| namespace internal { |
| |
| constexpr uint64_t kTestProtocol_StrictUnionHenceResponseMayBeStackAllocated_Ordinal = 0x5bfca9479251b9c3lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kTestProtocol_StrictUnionHenceResponseMayBeStackAllocated_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod; |
| |
| constexpr uint64_t kTestProtocol_FlexibleUnionHenceResponseMustBeHeapAllocated_Ordinal = 0x694fede3b8829ce2lu; |
| |
| constexpr ::fidl::MessageDynamicFlags kTestProtocol_FlexibleUnionHenceResponseMustBeHeapAllocated_DynamicFlags = ::fidl::MessageDynamicFlags::kStrictMethod;} // namespace internal |
| |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class TestProtocol { |
| public: |
| using Proxy_ = ::test::union_::TestProtocol_Proxy; |
| using Stub_ = ::test::union_::TestProtocol_Stub; |
| using EventSender_ = ::test::union_::TestProtocol_EventSender; |
| using Sync_ = ::test::union_::TestProtocol_Sync; |
| virtual ~TestProtocol(); |
| using StrictUnionHenceResponseMayBeStackAllocatedCallback = |
| fit::function<void(::test::union_::StrictBoundedUnion)>; |
| |
| virtual void StrictUnionHenceResponseMayBeStackAllocated(StrictUnionHenceResponseMayBeStackAllocatedCallback callback) = 0; |
| using FlexibleUnionHenceResponseMustBeHeapAllocatedCallback = |
| fit::function<void(::test::union_::OlderSimpleUnion)>; |
| |
| virtual void FlexibleUnionHenceResponseMustBeHeapAllocated(FlexibleUnionHenceResponseMustBeHeapAllocatedCallback callback) = 0; |
| |
| |
| }; |
| |
| class TestProtocol_RequestDecoder { |
| public: |
| TestProtocol_RequestDecoder() = default; |
| virtual ~TestProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response, bool* is_known); |
| virtual void StrictUnionHenceResponseMayBeStackAllocated() = 0; |
| virtual void FlexibleUnionHenceResponseMustBeHeapAllocated() = 0; |
| }; |
| |
| class TestProtocol_ResponseDecoder { |
| public: |
| TestProtocol_ResponseDecoder() = default; |
| virtual ~TestProtocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void StrictUnionHenceResponseMayBeStackAllocated(::test::union_::StrictBoundedUnion xu) = 0; |
| virtual void FlexibleUnionHenceResponseMustBeHeapAllocated(::test::union_::OlderSimpleUnion xu) = 0; |
| }; |
| |
| class TestProtocol_EventSender { |
| public: |
| virtual ~TestProtocol_EventSender(); |
| }; |
| |
| class TestProtocol_Sync { |
| public: |
| using Proxy_ = ::test::union_::TestProtocol_SyncProxy; |
| virtual ~TestProtocol_Sync(); |
| virtual zx_status_t StrictUnionHenceResponseMayBeStackAllocated(::test::union_::StrictBoundedUnion* out_xu) = 0; |
| virtual zx_status_t FlexibleUnionHenceResponseMustBeHeapAllocated(::test::union_::OlderSimpleUnion* out_xu) = 0; |
| }; |
| |
| class TestProtocol_Proxy final : public ::fidl::internal::Proxy, public TestProtocol { |
| public: |
| explicit TestProtocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~TestProtocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| // cts-coverage-fidl-name:test.union/TestProtocol.StrictUnionHenceResponseMayBeStackAllocated |
| void StrictUnionHenceResponseMayBeStackAllocated(StrictUnionHenceResponseMayBeStackAllocatedCallback callback) override; |
| // cts-coverage-fidl-name:test.union/TestProtocol.FlexibleUnionHenceResponseMustBeHeapAllocated |
| void FlexibleUnionHenceResponseMustBeHeapAllocated(FlexibleUnionHenceResponseMustBeHeapAllocatedCallback callback) override; |
| |
| |
| |
| |
| private: |
| TestProtocol_Proxy(const ::test::union_::TestProtocol_Proxy&) = delete; |
| TestProtocol_Proxy& operator=(const ::test::union_::TestProtocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class TestProtocol_Stub final : public ::fidl::internal::Stub, public ::test::union_::TestProtocol_EventSender { |
| public: |
| typedef class ::test::union_::TestProtocol TestProtocol_clazz; |
| explicit TestProtocol_Stub(::test::union_::TestProtocol_Stub::TestProtocol_clazz* impl); |
| ~TestProtocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| |
| private: |
| ::test::union_::TestProtocol_Stub::TestProtocol_clazz* impl_; |
| }; |
| |
| class TestProtocol_SyncProxy : public ::test::union_::TestProtocol_Sync { |
| public: |
| explicit TestProtocol_SyncProxy(::zx::channel channel); |
| ~TestProtocol_SyncProxy() override; |
| // cts-coverage-fidl-name:test.union/TestProtocol.StrictUnionHenceResponseMayBeStackAllocated |
| zx_status_t StrictUnionHenceResponseMayBeStackAllocated(::test::union_::StrictBoundedUnion* out_xu) override; |
| // cts-coverage-fidl-name:test.union/TestProtocol.FlexibleUnionHenceResponseMustBeHeapAllocated |
| zx_status_t FlexibleUnionHenceResponseMustBeHeapAllocated(::test::union_::OlderSimpleUnion* out_xu) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<TestProtocol>; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| } // namespace union_ |
| } // namespace test |
| |
| |