| // WARNING: This file is machine generated by fidlgen. |
| |
| // fidl_experiment = output_index_json |
| |
| #pragma once |
| |
| #include <cinttypes> |
| |
| #include <lib/fidl/cpp/wire/internal/framework_err.h> |
| #include <lib/fidl/cpp/wire/array.h> |
| #include <lib/fidl/cpp/wire/envelope.h> |
| #include <lib/fidl/cpp/wire/message_storage.h> |
| #include <lib/fidl/cpp/wire/message.h> |
| #include <lib/fidl/cpp/wire/object_view.h> |
| #include <lib/fidl/cpp/wire/string_view.h> |
| #include <lib/fidl/cpp/wire/traits.h> |
| #include <lib/fidl/cpp/wire/wire_types.h> |
| #include <lib/stdcompat/optional.h> |
| #ifdef __Fuchsia__ |
| #include <lib/zx/channel.h> |
| #include <lib/zx/handle.h> |
| #include <lib/zx/vmo.h> |
| |
| |
| #endif // __Fuchsia__ |
| |
| |
| #include <fidl/test.typesinprotocols/cpp/markers.h> |
| #include <fidl/test.typesinprotocols/cpp/common_types.h> |
| |
| |
| #pragma clang diagnostic push |
| #pragma clang diagnostic ignored "-Wshadow" |
| |
| namespace test_typesinprotocols { |
| |
| |
| |
| namespace wire { |
| using Bits = ::test_typesinprotocols::Bits; |
| |
| |
| using Enum = ::test_typesinprotocols::Enum; |
| |
| |
| |
| struct Struct; |
| |
| |
| struct ResourceStruct; |
| |
| |
| struct Basic; |
| |
| |
| struct Compound; |
| |
| |
| struct ArrayBasic; |
| |
| |
| struct ArrayCompound; |
| |
| |
| struct VectorBasic; |
| |
| |
| struct VectorCompound; |
| |
| |
| struct VectorOptional; |
| |
| |
| struct ArrayVectorNested; |
| |
| |
| struct Resource; |
| |
| |
| |
| class Table; |
| |
| |
| class ResourceTable; |
| |
| |
| |
| class Union; |
| |
| |
| class ResourceUnion; |
| |
| |
| class ProtocolErrorBasicResult; |
| |
| |
| class ProtocolErrorCompoundResult; |
| |
| |
| class ProtocolErrorArrayBasicResult; |
| |
| |
| class ProtocolErrorArrayCompoundResult; |
| |
| |
| class ProtocolErrorVectorBasicResult; |
| |
| |
| class ProtocolErrorVectorCompoundResult; |
| |
| |
| class ProtocolErrorVectorOptionalResult; |
| |
| |
| class ProtocolErrorArrayVectorNestedResult; |
| |
| |
| class ProtocolErrorResourceResult; |
| |
| |
| |
| |
| |
| |
| |
| struct Struct { |
| |
| uint8_t __reserved = {}; |
| }; |
| |
| |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| struct ResourceStruct { |
| |
| uint8_t __reserved = {}; |
| |
| void _CloseHandles(); |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| } // namespace wire |
| } // namespace test_typesinprotocols |
| |
| template<> |
| class ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table>; |
| template<> |
| class ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table>; |
| |
| template <> |
| struct ::fidl::WireTableFrame<::test_typesinprotocols::wire::Table> final { |
| public: |
| WireTableFrame() = default; |
| // In its intended usage, WireTableFrame will be referenced by an ObjectView. |
| // If the ObjectView is assigned before a move or copy, then it will reference |
| // the old invalid object. Because this is unsafe, copies are disallowed and |
| // moves are only allowed by friend classes that operate safely. |
| WireTableFrame(const WireTableFrame&) = delete; |
| WireTableFrame& operator=(const WireTableFrame&) = delete; |
| |
| private: |
| WireTableFrame(WireTableFrame&&) noexcept = default; |
| WireTableFrame& operator=(WireTableFrame&&) noexcept = default; |
| |
| bool HasUnknownData() const; |
| uint64_t ComputeMaxOrdinal() const; |
| |
| friend class ::test_typesinprotocols::wire::Table; |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table>>; |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table>>; |
| }; |
| |
| namespace test_typesinprotocols { |
| namespace wire { |
| |
| |
| class Table { |
| public: |
| Table() = default; |
| Table(const Table& other) noexcept = default; |
| Table& operator=(const Table& other) noexcept = default; |
| Table(Table&& other) noexcept = default; |
| Table& operator=(Table&& other) noexcept = default; |
| |
| ~Table() = default; |
| |
| // Returns whether no field is set. |
| bool IsEmpty() const { return max_ordinal_ == 0; } |
| |
| // Returns whether the table references unknown fields. |
| bool HasUnknownData() const; |
| |
| // Return a builder that by defaults allocates of an arena. |
| static ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table> Builder(::fidl::AnyArena& arena); |
| |
| // Return a builder that relies on explicitly allocating |fidl::ObjectView|s. |
| static ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table> ExternalBuilder(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>> frame); |
| #if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false |
| public: |
| #else // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) |
| private: |
| #endif // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES |
| |
| |
| explicit Table(::fidl::AnyArena& allocator) |
| : frame_ptr_(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>>(allocator)) {} |
| // This constructor allows a user controlled allocation (not using a Arena). |
| // It should only be used when performance is key. |
| // As soon as the frame is given to the table, it must not be used directly or for another table. |
| explicit Table(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>>&& frame) |
| : frame_ptr_(std::move(frame)) {} |
| |
| void Allocate(::fidl::AnyArena& allocator) { |
| max_ordinal_ = 0; |
| frame_ptr_ = ::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>>(allocator); |
| } |
| void Init(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>>&& frame_ptr) { |
| max_ordinal_ = 0; |
| frame_ptr_ = std::move(frame_ptr); |
| } |
| |
| private: |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table>>; |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table>>; |
| |
| uint64_t max_ordinal_ = 0; |
| ::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>> frame_ptr_; |
| };} // namespace wire |
| } // namespace test_typesinprotocols |
| |
| template<typename BuilderImpl> |
| class ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, BuilderImpl> { |
| protected: |
| // |Wrapper_Ignore_Me_| wraps a |fidl::ObjectView<T>| and reduces its |
| // priority in overload resolution. When the user writes `{}` as the |
| // setter argument, that would default construct the field instead of |
| // constructing a NULL object view. |
| template <typename U> |
| struct Wrapper_Ignore_Me_ { |
| Wrapper_Ignore_Me_(U v) : value(v) {} |
| U value; |
| }; |
| |
| public: |
| // Build and return the table. The builder should not be used after this. |
| ::test_typesinprotocols::wire::Table Build() { |
| ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr); |
| ::test_typesinprotocols::wire::Table t = std::move(table_); |
| // Poison this builder to prevent accidental reuse. |
| table_.frame_ptr_ = nullptr; |
| return t; |
| } |
| protected: |
| WireTableBaseBuilder(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>>&& frame) |
| : table_(std::move(frame)) {} |
| |
| private: |
| ::test_typesinprotocols::wire::Table table_; |
| }; |
| |
| template<> |
| class ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table> final : public ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table>> { |
| using Base = ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table>>; |
| |
| public: |
| private: |
| friend class ::test_typesinprotocols::wire::Table; |
| WireTableBuilder(::fidl::AnyArena& arena) |
| : Base(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>>(arena)), |
| arena_(arena) {} |
| |
| [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_; |
| |
| }; |
| |
| template<> |
| class ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table> final : public ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table>> { |
| using Base = ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::Table, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table>>; |
| |
| private: |
| friend class ::test_typesinprotocols::wire::Table; |
| using Base::Base; |
| WireTableExternalBuilder(::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>* frame) |
| : Base(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>>::FromExternal(frame)) {} |
| };namespace test_typesinprotocols { |
| namespace wire { |
| |
| inline ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table> Table::Builder(::fidl::AnyArena& arena) { |
| return ::fidl::WireTableBuilder<::test_typesinprotocols::wire::Table>(arena); |
| } |
| inline ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table> Table::ExternalBuilder(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::Table>> frame) { |
| return ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::Table>(std::move(frame)); |
| } |
| |
| #ifdef __Fuchsia__ |
| |
| |
| } // namespace wire |
| } // namespace test_typesinprotocols |
| |
| template<> |
| class ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable>; |
| template<> |
| class ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable>; |
| |
| template <> |
| struct ::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable> final { |
| public: |
| WireTableFrame() = default; |
| // In its intended usage, WireTableFrame will be referenced by an ObjectView. |
| // If the ObjectView is assigned before a move or copy, then it will reference |
| // the old invalid object. Because this is unsafe, copies are disallowed and |
| // moves are only allowed by friend classes that operate safely. |
| WireTableFrame(const WireTableFrame&) = delete; |
| WireTableFrame& operator=(const WireTableFrame&) = delete; |
| |
| private: |
| WireTableFrame(WireTableFrame&&) noexcept = default; |
| WireTableFrame& operator=(WireTableFrame&&) noexcept = default; |
| |
| bool HasUnknownData() const; |
| uint64_t ComputeMaxOrdinal() const; |
| |
| friend class ::test_typesinprotocols::wire::ResourceTable; |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable>>; |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable>>; |
| }; |
| |
| namespace test_typesinprotocols { |
| namespace wire { |
| |
| |
| class ResourceTable { |
| public: |
| ResourceTable() = default; |
| ResourceTable(const ResourceTable& other) noexcept = default; |
| ResourceTable& operator=(const ResourceTable& other) noexcept = default; |
| ResourceTable(ResourceTable&& other) noexcept = default; |
| ResourceTable& operator=(ResourceTable&& other) noexcept = default; |
| |
| ~ResourceTable() = default; |
| |
| // Returns whether no field is set. |
| bool IsEmpty() const { return max_ordinal_ == 0; } |
| |
| // Returns whether the table references unknown fields. |
| bool HasUnknownData() const; |
| void _CloseHandles(); |
| |
| // Return a builder that by defaults allocates of an arena. |
| static ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable> Builder(::fidl::AnyArena& arena); |
| |
| // Return a builder that relies on explicitly allocating |fidl::ObjectView|s. |
| static ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable> ExternalBuilder(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>> frame); |
| #if defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) || false |
| public: |
| #else // !defined(FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES) |
| private: |
| #endif // FIDL_WIRE_ALLOW_DEPRECATED_MUTABLE_TABLES |
| |
| |
| explicit ResourceTable(::fidl::AnyArena& allocator) |
| : frame_ptr_(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>>(allocator)) {} |
| // This constructor allows a user controlled allocation (not using a Arena). |
| // It should only be used when performance is key. |
| // As soon as the frame is given to the table, it must not be used directly or for another table. |
| explicit ResourceTable(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>>&& frame) |
| : frame_ptr_(std::move(frame)) {} |
| |
| void Allocate(::fidl::AnyArena& allocator) { |
| max_ordinal_ = 0; |
| frame_ptr_ = ::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>>(allocator); |
| } |
| void Init(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>>&& frame_ptr) { |
| max_ordinal_ = 0; |
| frame_ptr_ = std::move(frame_ptr); |
| } |
| |
| private: |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable>>; |
| friend ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable>>; |
| |
| uint64_t max_ordinal_ = 0; |
| ::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>> frame_ptr_; |
| };} // namespace wire |
| } // namespace test_typesinprotocols |
| |
| template<typename BuilderImpl> |
| class ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, BuilderImpl> { |
| protected: |
| // |Wrapper_Ignore_Me_| wraps a |fidl::ObjectView<T>| and reduces its |
| // priority in overload resolution. When the user writes `{}` as the |
| // setter argument, that would default construct the field instead of |
| // constructing a NULL object view. |
| template <typename U> |
| struct Wrapper_Ignore_Me_ { |
| Wrapper_Ignore_Me_(U v) : value(v) {} |
| U value; |
| }; |
| |
| public: |
| // Build and return the table. The builder should not be used after this. |
| ::test_typesinprotocols::wire::ResourceTable Build() { |
| ZX_DEBUG_ASSERT(table_.frame_ptr_ != nullptr); |
| ::test_typesinprotocols::wire::ResourceTable t = std::move(table_); |
| // Poison this builder to prevent accidental reuse. |
| table_.frame_ptr_ = nullptr; |
| return t; |
| } |
| protected: |
| WireTableBaseBuilder(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>>&& frame) |
| : table_(std::move(frame)) {} |
| |
| private: |
| ::test_typesinprotocols::wire::ResourceTable table_; |
| }; |
| |
| template<> |
| class ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable> final : public ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable>> { |
| using Base = ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable>>; |
| |
| public: |
| private: |
| friend class ::test_typesinprotocols::wire::ResourceTable; |
| WireTableBuilder(::fidl::AnyArena& arena) |
| : Base(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>>(arena)), |
| arena_(arena) {} |
| |
| [[maybe_unused]] std::reference_wrapper<::fidl::AnyArena> arena_; |
| |
| }; |
| |
| template<> |
| class ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable> final : public ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable>> { |
| using Base = ::fidl::internal::WireTableBaseBuilder<::test_typesinprotocols::wire::ResourceTable, ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable>>; |
| |
| private: |
| friend class ::test_typesinprotocols::wire::ResourceTable; |
| using Base::Base; |
| WireTableExternalBuilder(::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>* frame) |
| : Base(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>>::FromExternal(frame)) {} |
| };namespace test_typesinprotocols { |
| namespace wire { |
| |
| inline ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable> ResourceTable::Builder(::fidl::AnyArena& arena) { |
| return ::fidl::WireTableBuilder<::test_typesinprotocols::wire::ResourceTable>(arena); |
| } |
| inline ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable> ResourceTable::ExternalBuilder(::fidl::ObjectView<::fidl::WireTableFrame<::test_typesinprotocols::wire::ResourceTable>> frame) { |
| return ::fidl::WireTableExternalBuilder<::test_typesinprotocols::wire::ResourceTable>(std::move(frame)); |
| } |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| class Union { |
| public: |
| |
| Union() : ordinal_(::test_typesinprotocols::wire::Union::Ordinal::Invalid), envelope_{} {} |
| |
| Union(const Union&) = default; |
| Union& operator=(const Union&) = default; |
| Union(Union&&) = default; |
| Union& operator=(Union&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kB = 1, // 0x1 |
| _do_not_handle_this__write_a_default_case_instead = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| constexpr bool IsUnknown() const { |
| return Which() == ::test_typesinprotocols::wire::Union::Tag::_do_not_handle_this__write_a_default_case_instead; |
| } |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::Union::Ordinal::Invalid; } |
| |
| bool is_b() const { return ordinal_ == ::test_typesinprotocols::wire::Union::Ordinal::kB; } |
| |
| static Union WithB(bool val) { |
| Union result; |
| result.ordinal_ = ::test_typesinprotocols::wire::Union::Ordinal::kB; |
| result.envelope_.As<bool>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| bool& b() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::Union::Ordinal::kB); |
| return envelope_.As<bool>().get_data(); |
| } |
| const bool& b() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::Union::Ordinal::kB); |
| return envelope_.As<bool>().get_data(); |
| } |
| ::test_typesinprotocols::wire::Union::Tag Which() const; |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kB = 1, // 0x1 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::Union::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| class ResourceUnion { |
| public: |
| |
| ResourceUnion() : ordinal_(::test_typesinprotocols::wire::ResourceUnion::Ordinal::Invalid), envelope_{} {} |
| |
| |
| ~ResourceUnion(); |
| ResourceUnion(ResourceUnion&& other) { |
| _Move(std::move(other)); |
| } |
| ResourceUnion& operator=(ResourceUnion&& other) { |
| if (this != &other) { |
| _Move(std::move(other)); |
| } |
| return *this; |
| } |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kB = 1, // 0x1 |
| _do_not_handle_this__write_a_default_case_instead = ::std::numeric_limits<::fidl_union_tag_t>::max(), |
| }; |
| constexpr bool IsUnknown() const { |
| return Which() == ::test_typesinprotocols::wire::ResourceUnion::Tag::_do_not_handle_this__write_a_default_case_instead; |
| } |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ResourceUnion::Ordinal::Invalid; } |
| |
| bool is_b() const { return ordinal_ == ::test_typesinprotocols::wire::ResourceUnion::Ordinal::kB; } |
| |
| static ResourceUnion WithB(bool val) { |
| ResourceUnion result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ResourceUnion::Ordinal::kB; |
| result.envelope_.As<bool>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| bool& b() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ResourceUnion::Ordinal::kB); |
| return envelope_.As<bool>().get_data(); |
| } |
| const bool& b() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ResourceUnion::Ordinal::kB); |
| return envelope_.As<bool>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ResourceUnion::Tag Which() const; |
| void _CloseHandles(); |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kB = 1, // 0x1 |
| }; |
| void _Move(ResourceUnion&& other); |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ResourceUnion::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| |
| class ProtocolErrorBasicResult { |
| public: |
| |
| ProtocolErrorBasicResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorBasicResult(const ProtocolErrorBasicResult&) = default; |
| ProtocolErrorBasicResult& operator=(const ProtocolErrorBasicResult&) = default; |
| ProtocolErrorBasicResult(ProtocolErrorBasicResult&&) = default; |
| ProtocolErrorBasicResult& operator=(ProtocolErrorBasicResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorBasicResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::Basic> val) { |
| ProtocolErrorBasicResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::Basic>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorBasicResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::Basic>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::Basic& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::Basic>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::Basic& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::Basic>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kErr; } |
| |
| static ProtocolErrorBasicResult WithErr(uint32_t val) { |
| ProtocolErrorBasicResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| |
| class ProtocolErrorCompoundResult { |
| public: |
| |
| ProtocolErrorCompoundResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorCompoundResult(const ProtocolErrorCompoundResult&) = default; |
| ProtocolErrorCompoundResult& operator=(const ProtocolErrorCompoundResult&) = default; |
| ProtocolErrorCompoundResult(ProtocolErrorCompoundResult&&) = default; |
| ProtocolErrorCompoundResult& operator=(ProtocolErrorCompoundResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorCompoundResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::Compound> val) { |
| ProtocolErrorCompoundResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::Compound>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorCompoundResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::Compound>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::Compound& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::Compound>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::Compound& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::Compound>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kErr; } |
| |
| static ProtocolErrorCompoundResult WithErr(uint32_t val) { |
| ProtocolErrorCompoundResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| |
| class ProtocolErrorArrayBasicResult { |
| public: |
| |
| ProtocolErrorArrayBasicResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorArrayBasicResult(const ProtocolErrorArrayBasicResult&) = default; |
| ProtocolErrorArrayBasicResult& operator=(const ProtocolErrorArrayBasicResult&) = default; |
| ProtocolErrorArrayBasicResult(ProtocolErrorArrayBasicResult&&) = default; |
| ProtocolErrorArrayBasicResult& operator=(ProtocolErrorArrayBasicResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorArrayBasicResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::ArrayBasic> val) { |
| ProtocolErrorArrayBasicResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::ArrayBasic>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorArrayBasicResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::ArrayBasic>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::ArrayBasic& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::ArrayBasic>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::ArrayBasic& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::ArrayBasic>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kErr; } |
| |
| static ProtocolErrorArrayBasicResult WithErr(uint32_t val) { |
| ProtocolErrorArrayBasicResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| |
| class ProtocolErrorArrayCompoundResult { |
| public: |
| |
| ProtocolErrorArrayCompoundResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorArrayCompoundResult(const ProtocolErrorArrayCompoundResult&) = default; |
| ProtocolErrorArrayCompoundResult& operator=(const ProtocolErrorArrayCompoundResult&) = default; |
| ProtocolErrorArrayCompoundResult(ProtocolErrorArrayCompoundResult&&) = default; |
| ProtocolErrorArrayCompoundResult& operator=(ProtocolErrorArrayCompoundResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorArrayCompoundResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::ArrayCompound> val) { |
| ProtocolErrorArrayCompoundResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::ArrayCompound>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorArrayCompoundResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::ArrayCompound>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::ArrayCompound& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::ArrayCompound>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::ArrayCompound& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::ArrayCompound>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kErr; } |
| |
| static ProtocolErrorArrayCompoundResult WithErr(uint32_t val) { |
| ProtocolErrorArrayCompoundResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| |
| class ProtocolErrorVectorBasicResult { |
| public: |
| |
| ProtocolErrorVectorBasicResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorVectorBasicResult(const ProtocolErrorVectorBasicResult&) = default; |
| ProtocolErrorVectorBasicResult& operator=(const ProtocolErrorVectorBasicResult&) = default; |
| ProtocolErrorVectorBasicResult(ProtocolErrorVectorBasicResult&&) = default; |
| ProtocolErrorVectorBasicResult& operator=(ProtocolErrorVectorBasicResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorVectorBasicResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::VectorBasic> val) { |
| ProtocolErrorVectorBasicResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::VectorBasic>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorVectorBasicResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::VectorBasic>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::VectorBasic& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::VectorBasic>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::VectorBasic& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::VectorBasic>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kErr; } |
| |
| static ProtocolErrorVectorBasicResult WithErr(uint32_t val) { |
| ProtocolErrorVectorBasicResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| |
| class ProtocolErrorVectorCompoundResult { |
| public: |
| |
| ProtocolErrorVectorCompoundResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorVectorCompoundResult(const ProtocolErrorVectorCompoundResult&) = default; |
| ProtocolErrorVectorCompoundResult& operator=(const ProtocolErrorVectorCompoundResult&) = default; |
| ProtocolErrorVectorCompoundResult(ProtocolErrorVectorCompoundResult&&) = default; |
| ProtocolErrorVectorCompoundResult& operator=(ProtocolErrorVectorCompoundResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorVectorCompoundResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::VectorCompound> val) { |
| ProtocolErrorVectorCompoundResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::VectorCompound>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorVectorCompoundResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::VectorCompound>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::VectorCompound& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::VectorCompound>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::VectorCompound& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::VectorCompound>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kErr; } |
| |
| static ProtocolErrorVectorCompoundResult WithErr(uint32_t val) { |
| ProtocolErrorVectorCompoundResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| |
| class ProtocolErrorVectorOptionalResult { |
| public: |
| |
| ProtocolErrorVectorOptionalResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorVectorOptionalResult(const ProtocolErrorVectorOptionalResult&) = default; |
| ProtocolErrorVectorOptionalResult& operator=(const ProtocolErrorVectorOptionalResult&) = default; |
| ProtocolErrorVectorOptionalResult(ProtocolErrorVectorOptionalResult&&) = default; |
| ProtocolErrorVectorOptionalResult& operator=(ProtocolErrorVectorOptionalResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorVectorOptionalResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::VectorOptional> val) { |
| ProtocolErrorVectorOptionalResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::VectorOptional>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorVectorOptionalResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::VectorOptional>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::VectorOptional& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::VectorOptional>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::VectorOptional& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::VectorOptional>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kErr; } |
| |
| static ProtocolErrorVectorOptionalResult WithErr(uint32_t val) { |
| ProtocolErrorVectorOptionalResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| |
| class ProtocolErrorArrayVectorNestedResult { |
| public: |
| |
| ProtocolErrorArrayVectorNestedResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::Invalid), envelope_{} {} |
| |
| ProtocolErrorArrayVectorNestedResult(const ProtocolErrorArrayVectorNestedResult&) = default; |
| ProtocolErrorArrayVectorNestedResult& operator=(const ProtocolErrorArrayVectorNestedResult&) = default; |
| ProtocolErrorArrayVectorNestedResult(ProtocolErrorArrayVectorNestedResult&&) = default; |
| ProtocolErrorArrayVectorNestedResult& operator=(ProtocolErrorArrayVectorNestedResult&&) = default; |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorArrayVectorNestedResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::ArrayVectorNested> val) { |
| ProtocolErrorArrayVectorNestedResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::ArrayVectorNested>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorArrayVectorNestedResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::ArrayVectorNested>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::ArrayVectorNested& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::ArrayVectorNested>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::ArrayVectorNested& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::ArrayVectorNested>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kErr; } |
| |
| static ProtocolErrorArrayVectorNestedResult WithErr(uint32_t val) { |
| ProtocolErrorArrayVectorNestedResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag>(ordinal_); |
| } |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| class ProtocolErrorResourceResult { |
| public: |
| |
| ProtocolErrorResourceResult() : ordinal_(::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::Invalid), envelope_{} {} |
| |
| |
| ~ProtocolErrorResourceResult(); |
| ProtocolErrorResourceResult(ProtocolErrorResourceResult&& other) { |
| _Move(std::move(other)); |
| } |
| ProtocolErrorResourceResult& operator=(ProtocolErrorResourceResult&& other) { |
| if (this != &other) { |
| _Move(std::move(other)); |
| } |
| return *this; |
| } |
| |
| enum class Tag : fidl_xunion_tag_t { |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| |
| bool has_invalid_tag() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::Invalid; } |
| |
| bool is_response() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kResponse; } |
| |
| static ProtocolErrorResourceResult WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::Resource> val) { |
| ProtocolErrorResourceResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kResponse; |
| result.envelope_.As<::test_typesinprotocols::wire::Resource>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| template <typename... Args> |
| static ProtocolErrorResourceResult WithResponse(::fidl::AnyArena& allocator, Args&&... args) { |
| return WithResponse(::fidl::ObjectView<::test_typesinprotocols::wire::Resource>(allocator, |
| std::forward<Args>(args)...)); |
| } |
| |
| |
| ::test_typesinprotocols::wire::Resource& response() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::Resource>().get_data(); |
| } |
| const ::test_typesinprotocols::wire::Resource& response() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kResponse); |
| return envelope_.As<::test_typesinprotocols::wire::Resource>().get_data(); |
| } |
| |
| bool is_err() const { return ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kErr; } |
| |
| static ProtocolErrorResourceResult WithErr(uint32_t val) { |
| ProtocolErrorResourceResult result; |
| result.ordinal_ = ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kErr; |
| result.envelope_.As<uint32_t>().set_data(std::move(val)); |
| return result; |
| } |
| |
| |
| uint32_t& err() { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| const uint32_t& err() const { |
| ZX_ASSERT(ordinal_ == ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal::kErr); |
| return envelope_.As<uint32_t>().get_data(); |
| } |
| ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag Which() const { |
| ZX_ASSERT(!has_invalid_tag()); |
| return static_cast<::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag>(ordinal_); |
| } |
| void _CloseHandles(); |
| |
| private: |
| enum class Ordinal : fidl_xunion_tag_t { |
| Invalid = 0, |
| kResponse = 1, // 0x1 |
| kErr = 2, // 0x2 |
| }; |
| void _Move(ProtocolErrorResourceResult&& other); |
| |
| static void SizeAndOffsetAssertionHelper(); |
| ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Ordinal ordinal_; |
| FIDL_ALIGNDECL |
| ::fidl::UntypedEnvelope envelope_; |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| struct Basic { |
| |
| uint8_t uint8 = {}; |
| |
| uint16_t uint16 = {}; |
| |
| uint32_t uint32 = {}; |
| |
| uint64_t uint64 = {}; |
| |
| int8_t int8 = {}; |
| |
| int16_t int16 = {}; |
| |
| int32_t int32 = {}; |
| |
| int64_t int64 = {}; |
| |
| float float32 = {}; |
| |
| double float64 = {}; |
| |
| ::fidl::StringView string = {}; |
| |
| ::fidl::StringView opt_string = {}; |
| }; |
| |
| |
| |
| |
| |
| struct Compound { |
| |
| ::test_typesinprotocols::wire::Bits bits = {}; |
| |
| ::test_typesinprotocols::wire::Enum enum_ = {}; |
| |
| ::test_typesinprotocols::wire::Struct struct_ = {}; |
| |
| ::test_typesinprotocols::wire::Table table = {}; |
| |
| ::test_typesinprotocols::wire::Union union_ = {}; |
| |
| ::fidl::ObjectView<::test_typesinprotocols::wire::Struct> opt_struct = {}; |
| |
| ::fidl::WireOptional<::test_typesinprotocols::wire::Union> opt_union = {}; |
| }; |
| |
| |
| |
| |
| |
| struct ArrayBasic { |
| |
| ::fidl::Array<uint8_t, 5> array_uint8 = {}; |
| |
| ::fidl::Array<uint16_t, 5> array_uint16 = {}; |
| |
| ::fidl::Array<uint32_t, 5> array_uint32 = {}; |
| |
| ::fidl::Array<uint64_t, 5> array_uint64 = {}; |
| |
| ::fidl::Array<int8_t, 5> array_int8 = {}; |
| |
| ::fidl::Array<int16_t, 5> array_int16 = {}; |
| |
| ::fidl::Array<int32_t, 5> array_int32 = {}; |
| |
| ::fidl::Array<int64_t, 5> array_int64 = {}; |
| |
| ::fidl::Array<float, 5> array_float32 = {}; |
| |
| ::fidl::Array<double, 5> array_float64 = {}; |
| |
| ::fidl::Array<::fidl::StringView, 5> array_string = {}; |
| |
| ::fidl::Array<::fidl::StringView, 5> array_opt_string = {}; |
| }; |
| |
| |
| |
| |
| |
| struct ArrayCompound { |
| |
| ::fidl::Array<::test_typesinprotocols::wire::Bits, 5> array_bits = {}; |
| |
| ::fidl::Array<::test_typesinprotocols::wire::Enum, 5> array_enum = {}; |
| |
| ::fidl::Array<::test_typesinprotocols::wire::Struct, 5> array_struct = {}; |
| |
| ::fidl::Array<::test_typesinprotocols::wire::Table, 5> array_table = {}; |
| |
| ::fidl::Array<::test_typesinprotocols::wire::Union, 5> array_union = {}; |
| |
| ::fidl::Array<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>, 5> array_opt_struct = {}; |
| |
| ::fidl::Array<::fidl::WireOptional<::test_typesinprotocols::wire::Union>, 5> array_opt_union = {}; |
| }; |
| |
| |
| |
| |
| |
| struct VectorBasic { |
| |
| ::fidl::VectorView<uint8_t> vector_uint8 = {}; |
| |
| ::fidl::VectorView<uint16_t> vector_uint16 = {}; |
| |
| ::fidl::VectorView<uint32_t> vector_uint32 = {}; |
| |
| ::fidl::VectorView<uint64_t> vector_uint64 = {}; |
| |
| ::fidl::VectorView<int8_t> vector_int8 = {}; |
| |
| ::fidl::VectorView<int16_t> vector_int16 = {}; |
| |
| ::fidl::VectorView<int32_t> vector_int32 = {}; |
| |
| ::fidl::VectorView<int64_t> vector_int64 = {}; |
| |
| ::fidl::VectorView<float> vector_float32 = {}; |
| |
| ::fidl::VectorView<double> vector_float64 = {}; |
| |
| ::fidl::VectorView<::fidl::StringView> vector_string = {}; |
| |
| ::fidl::VectorView<::fidl::StringView> vector_opt_string = {}; |
| }; |
| |
| |
| |
| |
| |
| struct VectorCompound { |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::Bits> vector_bits = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::Enum> vector_enum = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::Struct> vector_struct = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::Table> vector_table = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::Union> vector_union = {}; |
| |
| ::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>> vector_opt_struct = {}; |
| |
| ::fidl::VectorView<::fidl::WireOptional<::test_typesinprotocols::wire::Union>> vector_opt_union = {}; |
| }; |
| |
| |
| |
| |
| |
| struct VectorOptional { |
| |
| ::fidl::VectorView<uint8_t> opt_vector_uint8 = {}; |
| |
| ::fidl::VectorView<::fidl::StringView> opt_vector_string = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::Struct> opt_vector_struct = {}; |
| |
| ::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>> opt_vector_opt_struct = {}; |
| }; |
| |
| |
| |
| |
| |
| struct ArrayVectorNested { |
| |
| ::fidl::Array<::fidl::Array<uint8_t, 5>, 5> array_array_uint8 = {}; |
| |
| ::fidl::Array<::fidl::VectorView<uint8_t>, 5> array_vector_uint8 = {}; |
| |
| ::fidl::VectorView<::fidl::Array<uint8_t, 5>> vector_array_uint8 = {}; |
| |
| ::fidl::VectorView<::fidl::VectorView<uint8_t>> vector_vector_uint8 = {}; |
| }; |
| |
| |
| |
| |
| #ifdef __Fuchsia__ |
| |
| |
| struct Resource { |
| |
| ::zx::handle handle = {}; |
| |
| ::zx::vmo vmo = {}; |
| |
| ::fidl::ClientEnd<::test_typesinprotocols::Protocol> client_end = {}; |
| |
| ::fidl::ServerEnd<::test_typesinprotocols::Protocol> server_end = {}; |
| |
| ::test_typesinprotocols::wire::ResourceStruct struct_ = {}; |
| |
| ::test_typesinprotocols::wire::ResourceTable table = {}; |
| |
| ::test_typesinprotocols::wire::ResourceUnion union_ = {}; |
| |
| ::zx::handle opt_handle = {}; |
| |
| ::zx::vmo opt_vmo = {}; |
| |
| ::fidl::ClientEnd<::test_typesinprotocols::Protocol> opt_client_end = {}; |
| |
| ::fidl::ServerEnd<::test_typesinprotocols::Protocol> opt_server_end = {}; |
| |
| ::fidl::ObjectView<::test_typesinprotocols::wire::ResourceStruct> opt_struct = {}; |
| |
| ::fidl::WireOptional<::test_typesinprotocols::wire::ResourceUnion> opt_union = {}; |
| |
| ::fidl::Array<::zx::handle, 5> array_handle = {}; |
| |
| ::fidl::Array<::zx::vmo, 5> array_vmo = {}; |
| |
| ::fidl::Array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5> array_client_end = {}; |
| |
| ::fidl::Array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5> array_server_end = {}; |
| |
| ::fidl::Array<::test_typesinprotocols::wire::ResourceStruct, 5> array_struct = {}; |
| |
| ::fidl::Array<::test_typesinprotocols::wire::ResourceTable, 5> array_table = {}; |
| |
| ::fidl::Array<::test_typesinprotocols::wire::ResourceUnion, 5> array_union = {}; |
| |
| ::fidl::VectorView<::zx::handle> vector_handle = {}; |
| |
| ::fidl::VectorView<::zx::vmo> vector_vmo = {}; |
| |
| ::fidl::VectorView<::fidl::ClientEnd<::test_typesinprotocols::Protocol>> vector_client_end = {}; |
| |
| ::fidl::VectorView<::fidl::ServerEnd<::test_typesinprotocols::Protocol>> vector_server_end = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::ResourceStruct> vector_struct = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::ResourceTable> vector_table = {}; |
| |
| ::fidl::VectorView<::test_typesinprotocols::wire::ResourceUnion> vector_union = {}; |
| |
| void _CloseHandles(); |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| } // namespace wire |
| } // namespace test_typesinprotocols |
| namespace fidl { |
| |
| |
| |
| template <bool IsRecursive> |
| struct internal::WireCodingTraits<::test_typesinprotocols::wire::Bits, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = sizeof(uint32_t); |
| static constexpr bool kIsMemcpyCompatible = true; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Bits* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| *position.As<::test_typesinprotocols::wire::Bits>() = *value; |
| } |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| } |
| }; |
| |
| |
| |
| template <bool IsRecursive> |
| struct internal::WireCodingTraits<::test_typesinprotocols::wire::Enum, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = sizeof(uint32_t); |
| static constexpr bool kIsMemcpyCompatible = true; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Enum* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| *position.As<::test_typesinprotocols::wire::Enum>() = *value; |
| } |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| } |
| }; |
| |
| |
| |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::Struct> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 0; |
| static constexpr uint32_t kPrimarySize = 1; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::Struct> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::Struct> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::Struct> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::Struct>); |
| static_assert(offsetof(::test_typesinprotocols::wire::Struct, __reserved) == 0); |
| static_assert(sizeof(::test_typesinprotocols::wire::Struct) == TypeTraits<::test_typesinprotocols::wire::Struct>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Struct, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 1; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>()); |
| static constexpr bool kHasPadding = false; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::Struct, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Struct* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::Struct)); |
| } else { |
| internal::WireCodingTraits<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->__reserved, position + 0, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| } |
| if (*position.As<uint8_t>() != 0) { |
| decoder->SetError(kCodingErrorInvalidPaddingBytes); |
| } |
| } |
| }; |
| |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::test_typesinprotocols::wire::ResourceStruct> : public std::true_type {}; |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::ResourceStruct> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 0; |
| static constexpr uint32_t kPrimarySize = 1; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = false; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ResourceStruct> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ResourceStruct> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::ResourceStruct> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ResourceStruct>); |
| static_assert(offsetof(::test_typesinprotocols::wire::ResourceStruct, __reserved) == 0); |
| static_assert(sizeof(::test_typesinprotocols::wire::ResourceStruct) == TypeTraits<::test_typesinprotocols::wire::ResourceStruct>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceStruct, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 1; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>()); |
| static constexpr bool kHasPadding = false; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::ResourceStruct, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ResourceStruct* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::ResourceStruct)); |
| } else { |
| internal::WireCodingTraits<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->__reserved, position + 0, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| } |
| if (*position.As<uint8_t>() != 0) { |
| decoder->SetError(kCodingErrorInvalidPaddingBytes); |
| } |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::Basic> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 80; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::Basic> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::Basic> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::Basic> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::Basic>); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, uint8) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, uint16) == 2); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, uint32) == 4); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, uint64) == 8); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, int8) == 16); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, int16) == 18); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, int32) == 20); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, int64) == 24); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, float32) == 32); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, float64) == 40); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, string) == 48); |
| static_assert(offsetof(::test_typesinprotocols::wire::Basic, opt_string) == 64); |
| static_assert(sizeof(::test_typesinprotocols::wire::Basic) == TypeTraits<::test_typesinprotocols::wire::Basic>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Basic, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 80; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<uint16_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<uint64_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<int8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<int16_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<int32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<int64_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<float, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<double, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::StringView, fidl::internal::WireCodingConstraintString<false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::StringView, fidl::internal::WireCodingConstraintString<true>, IsRecursive>()); |
| static constexpr bool kHasPadding = true; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::Basic, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Basic* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::Basic)); |
| } else { |
| internal::WireZeroPadding<uint64_t>(encoder, position + 0); |
| internal::WireZeroPadding<uint64_t>(encoder, position + 16); |
| internal::WireZeroPadding<uint64_t>(encoder, position + 32); |
| internal::WireCodingTraits<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->uint8, position + 0, recursion_depth); |
| internal::WireCodingTraits<uint16_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->uint16, position + 2, recursion_depth); |
| internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->uint32, position + 4, recursion_depth); |
| internal::WireCodingTraits<uint64_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->uint64, position + 8, recursion_depth); |
| internal::WireCodingTraits<int8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->int8, position + 16, recursion_depth); |
| internal::WireCodingTraits<int16_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->int16, position + 18, recursion_depth); |
| internal::WireCodingTraits<int32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->int32, position + 20, recursion_depth); |
| internal::WireCodingTraits<int64_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->int64, position + 24, recursion_depth); |
| internal::WireCodingTraits<float, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->float32, position + 32, recursion_depth); |
| internal::WireCodingTraits<double, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->float64, position + 40, recursion_depth); |
| internal::WireCodingTraits<::fidl::StringView, fidl::internal::WireCodingConstraintString<false>, IsRecursive>::Encode(encoder, &value->string, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::StringView, fidl::internal::WireCodingConstraintString<true>, IsRecursive>::Encode(encoder, &value->opt_string, position + 64, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<uint8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<uint16_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 2, recursion_depth); |
| internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 4, recursion_depth); |
| internal::WireCodingTraits<uint64_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 8, recursion_depth); |
| internal::WireCodingTraits<int8_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 16, recursion_depth); |
| internal::WireCodingTraits<int16_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 18, recursion_depth); |
| internal::WireCodingTraits<int32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 20, recursion_depth); |
| internal::WireCodingTraits<int64_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 24, recursion_depth); |
| internal::WireCodingTraits<float, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 32, recursion_depth); |
| internal::WireCodingTraits<double, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 40, recursion_depth); |
| internal::WireCodingTraits<::fidl::StringView, fidl::internal::WireCodingConstraintString<false>, IsRecursive>::Decode( |
| decoder, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::StringView, fidl::internal::WireCodingConstraintString<true>, IsRecursive>::Decode( |
| decoder, position + 64, recursion_depth); |
| } |
| internal::WireCheckPadding<uint64_t>(decoder, position + 0, 0xff00); |
| internal::WireCheckPadding<uint64_t>(decoder, position + 16, 0xff00); |
| internal::WireCheckPadding<uint64_t>(decoder, position + 32, 0xffffffff00000000); |
| } |
| }; |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::Compound> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 72; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 8; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::Compound> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::Compound> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::Compound> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::Compound>); |
| static_assert(offsetof(::test_typesinprotocols::wire::Compound, bits) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::Compound, enum_) == 4); |
| static_assert(offsetof(::test_typesinprotocols::wire::Compound, struct_) == 8); |
| static_assert(offsetof(::test_typesinprotocols::wire::Compound, table) == 16); |
| static_assert(offsetof(::test_typesinprotocols::wire::Compound, union_) == 32); |
| static_assert(offsetof(::test_typesinprotocols::wire::Compound, opt_struct) == 48); |
| static_assert(offsetof(::test_typesinprotocols::wire::Compound, opt_union) == 56); |
| static_assert(sizeof(::test_typesinprotocols::wire::Compound) == TypeTraits<::test_typesinprotocols::wire::Compound>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Compound, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 72; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::Bits, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::Enum, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::Struct, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::Table, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::Union, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::WireOptional<::test_typesinprotocols::wire::Union>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>()); |
| static constexpr bool kHasPadding = true; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::Compound, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Compound* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::Compound)); |
| } else { |
| internal::WireZeroPadding<uint64_t>(encoder, position + 8); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Bits, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->bits, position + 0, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Enum, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->enum_, position + 4, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Struct, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->struct_, position + 8, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Table, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->table, position + 16, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Union, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Encode(encoder, &value->union_, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->opt_struct, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::WireOptional<::test_typesinprotocols::wire::Union>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>::Encode(encoder, &value->opt_union, position + 56, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Bits, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Enum, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 4, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Struct, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 8, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Table, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 16, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::Union, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Decode( |
| decoder, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::WireOptional<::test_typesinprotocols::wire::Union>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>::Decode( |
| decoder, position + 56, recursion_depth); |
| } |
| internal::WireCheckPadding<uint64_t>(decoder, position + 8, 0xffffffffffffff00); |
| } |
| }; |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::ArrayBasic> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 384; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ArrayBasic> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ArrayBasic> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::ArrayBasic> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ArrayBasic>); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_uint8) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_uint16) == 6); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_uint32) == 16); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_uint64) == 40); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_int8) == 80); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_int16) == 86); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_int32) == 96); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_int64) == 120); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_float32) == 160); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_float64) == 184); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_string) == 224); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayBasic, array_opt_string) == 304); |
| static_assert(sizeof(::test_typesinprotocols::wire::ArrayBasic) == TypeTraits<::test_typesinprotocols::wire::ArrayBasic>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayBasic, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 384; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<uint8_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<uint16_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<uint32_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<uint64_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<int8_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<int16_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<int32_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<int64_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<float, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<double, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::StringView, 5>, fidl::internal::WireCodingConstraintString<false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::StringView, 5>, fidl::internal::WireCodingConstraintString<true>, IsRecursive>()); |
| static constexpr bool kHasPadding = true; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::ArrayBasic, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ArrayBasic* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::ArrayBasic)); |
| } else { |
| internal::WireZeroPadding<uint64_t>(encoder, position + 0); |
| internal::WireZeroPadding<uint64_t>(encoder, position + 32); |
| internal::WireZeroPadding<uint64_t>(encoder, position + 80); |
| internal::WireZeroPadding<uint64_t>(encoder, position + 112); |
| internal::WireZeroPadding<uint64_t>(encoder, position + 176); |
| internal::WireCodingTraits<::fidl::Array<uint8_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_uint8, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<uint16_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_uint16, position + 6, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<uint32_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_uint32, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<uint64_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_uint64, position + 40, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int8_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_int8, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int16_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_int16, position + 86, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int32_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_int32, position + 96, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int64_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_int64, position + 120, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<float, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_float32, position + 160, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<double, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_float64, position + 184, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::StringView, 5>, fidl::internal::WireCodingConstraintString<false>, IsRecursive>::Encode(encoder, &value->array_string, position + 224, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::StringView, 5>, fidl::internal::WireCodingConstraintString<true>, IsRecursive>::Encode(encoder, &value->array_opt_string, position + 304, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::fidl::Array<uint8_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<uint16_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 6, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<uint32_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<uint64_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 40, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int8_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int16_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 86, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int32_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 96, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<int64_t, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 120, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<float, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 160, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<double, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 184, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::StringView, 5>, fidl::internal::WireCodingConstraintString<false>, IsRecursive>::Decode( |
| decoder, position + 224, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::StringView, 5>, fidl::internal::WireCodingConstraintString<true>, IsRecursive>::Decode( |
| decoder, position + 304, recursion_depth); |
| } |
| internal::WireCheckPadding<uint64_t>(decoder, position + 0, 0xff0000000000); |
| internal::WireCheckPadding<uint64_t>(decoder, position + 32, 0xffffffff00000000); |
| internal::WireCheckPadding<uint64_t>(decoder, position + 80, 0xff0000000000); |
| internal::WireCheckPadding<uint64_t>(decoder, position + 112, 0xffffffff00000000); |
| internal::WireCheckPadding<uint64_t>(decoder, position + 176, 0xffffffff00000000); |
| } |
| }; |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::ArrayCompound> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 328; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 40; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ArrayCompound> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ArrayCompound> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::ArrayCompound> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ArrayCompound>); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayCompound, array_bits) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayCompound, array_enum) == 20); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayCompound, array_struct) == 40); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayCompound, array_table) == 48); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayCompound, array_union) == 128); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayCompound, array_opt_struct) == 208); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayCompound, array_opt_union) == 248); |
| static_assert(sizeof(::test_typesinprotocols::wire::ArrayCompound) == TypeTraits<::test_typesinprotocols::wire::ArrayCompound>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayCompound, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 328; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::Bits, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::Enum, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::Struct, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::Table, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::Union, 5>, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::WireOptional<::test_typesinprotocols::wire::Union>, 5>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>()); |
| static constexpr bool kHasPadding = true; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::ArrayCompound, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ArrayCompound* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::ArrayCompound)); |
| } else { |
| internal::WireZeroPadding<uint64_t>(encoder, position + 40); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Bits, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_bits, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Enum, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_enum, position + 20, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Struct, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_struct, position + 40, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Table, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_table, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Union, 5>, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Encode(encoder, &value->array_union, position + 128, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_opt_struct, position + 208, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::WireOptional<::test_typesinprotocols::wire::Union>, 5>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>::Encode(encoder, &value->array_opt_union, position + 248, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Bits, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Enum, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 20, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Struct, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 40, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Table, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::Union, 5>, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Decode( |
| decoder, position + 128, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 208, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::WireOptional<::test_typesinprotocols::wire::Union>, 5>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>::Decode( |
| decoder, position + 248, recursion_depth); |
| } |
| internal::WireCheckPadding<uint64_t>(decoder, position + 40, 0xffffff0000000000); |
| } |
| }; |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::VectorBasic> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 192; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::VectorBasic> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::VectorBasic> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::VectorBasic> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::VectorBasic>); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_uint8) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_uint16) == 16); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_uint32) == 32); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_uint64) == 48); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_int8) == 64); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_int16) == 80); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_int32) == 96); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_int64) == 112); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_float32) == 128); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_float64) == 144); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_string) == 160); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorBasic, vector_opt_string) == 176); |
| static_assert(sizeof(::test_typesinprotocols::wire::VectorBasic) == TypeTraits<::test_typesinprotocols::wire::VectorBasic>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorBasic, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 192; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<uint8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<uint16_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<uint32_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<uint64_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<int8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<int16_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<int32_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<int64_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<float>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<double>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<false>, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<true>, false>, IsRecursive>()); |
| static constexpr bool kHasPadding = false; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::VectorBasic, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::VectorBasic* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::VectorBasic)); |
| } else { |
| internal::WireCodingTraits<::fidl::VectorView<uint8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_uint8, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<uint16_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_uint16, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<uint32_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_uint32, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<uint64_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_uint64, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_int8, position + 64, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int16_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_int16, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int32_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_int32, position + 96, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int64_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_int64, position + 112, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<float>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_float32, position + 128, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<double>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_float64, position + 144, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<false>, false>, IsRecursive>::Encode(encoder, &value->vector_string, position + 160, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<true>, false>, IsRecursive>::Encode(encoder, &value->vector_opt_string, position + 176, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::fidl::VectorView<uint8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<uint16_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<uint32_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<uint64_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 64, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int16_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int32_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 96, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<int64_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 112, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<float>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 128, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<double>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 144, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<false>, false>, IsRecursive>::Decode( |
| decoder, position + 160, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<true>, false>, IsRecursive>::Decode( |
| decoder, position + 176, recursion_depth); |
| } |
| } |
| }; |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::VectorCompound> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 112; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::VectorCompound> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::VectorCompound> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::VectorCompound> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::VectorCompound>); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorCompound, vector_bits) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorCompound, vector_enum) == 16); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorCompound, vector_struct) == 32); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorCompound, vector_table) == 48); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorCompound, vector_union) == 64); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorCompound, vector_opt_struct) == 80); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorCompound, vector_opt_union) == 96); |
| static_assert(sizeof(::test_typesinprotocols::wire::VectorCompound) == TypeTraits<::test_typesinprotocols::wire::VectorCompound>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorCompound, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 112; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::Bits>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::Enum>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::Table>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::Union>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<false>, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::WireOptional<::test_typesinprotocols::wire::Union>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<true>, false>, IsRecursive>()); |
| static constexpr bool kHasPadding = false; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::VectorCompound, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::VectorCompound* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::VectorCompound)); |
| } else { |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Bits>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_bits, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Enum>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_enum, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_struct, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Table>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_table, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Union>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<false>, false>, IsRecursive>::Encode(encoder, &value->vector_union, position + 64, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_opt_struct, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::WireOptional<::test_typesinprotocols::wire::Union>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<true>, false>, IsRecursive>::Encode(encoder, &value->vector_opt_union, position + 96, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Bits>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Enum>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Table>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 48, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Union>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<false>, false>, IsRecursive>::Decode( |
| decoder, position + 64, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::WireOptional<::test_typesinprotocols::wire::Union>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<true>, false>, IsRecursive>::Decode( |
| decoder, position + 96, recursion_depth); |
| } |
| } |
| }; |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::VectorOptional> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 64; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::VectorOptional> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::VectorOptional> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::VectorOptional> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::VectorOptional>); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorOptional, opt_vector_uint8) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorOptional, opt_vector_string) == 16); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorOptional, opt_vector_struct) == 32); |
| static_assert(offsetof(::test_typesinprotocols::wire::VectorOptional, opt_vector_opt_struct) == 48); |
| static_assert(sizeof(::test_typesinprotocols::wire::VectorOptional) == TypeTraits<::test_typesinprotocols::wire::VectorOptional>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorOptional, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 64; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<uint8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<false>, true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>()); |
| static constexpr bool kHasPadding = false; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::VectorOptional, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::VectorOptional* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::VectorOptional)); |
| } else { |
| internal::WireCodingTraits<::fidl::VectorView<uint8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>::Encode(encoder, &value->opt_vector_uint8, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<false>, true>, IsRecursive>::Encode(encoder, &value->opt_vector_string, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>::Encode(encoder, &value->opt_vector_struct, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>::Encode(encoder, &value->opt_vector_opt_struct, position + 48, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::fidl::VectorView<uint8_t>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::StringView>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintString<false>, true>, IsRecursive>::Decode( |
| decoder, position + 16, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::Struct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>::Decode( |
| decoder, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ObjectView<::test_typesinprotocols::wire::Struct>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, true>, IsRecursive>::Decode( |
| decoder, position + 48, recursion_depth); |
| } |
| } |
| }; |
| |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::ArrayVectorNested> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 144; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ArrayVectorNested> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ArrayVectorNested> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::ArrayVectorNested> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ArrayVectorNested>); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayVectorNested, array_array_uint8) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayVectorNested, array_vector_uint8) == 32); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayVectorNested, vector_array_uint8) == 112); |
| static_assert(offsetof(::test_typesinprotocols::wire::ArrayVectorNested, vector_vector_uint8) == 128); |
| static_assert(sizeof(::test_typesinprotocols::wire::ArrayVectorNested) == TypeTraits<::test_typesinprotocols::wire::ArrayVectorNested>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayVectorNested, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 144; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::Array<uint8_t, 5>, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::VectorView<uint8_t>, 5>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::Array<uint8_t, 5>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::VectorView<uint8_t>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, false>, IsRecursive>()); |
| static constexpr bool kHasPadding = true; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::ArrayVectorNested, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ArrayVectorNested* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::ArrayVectorNested)); |
| } else { |
| internal::WireZeroPadding<uint64_t>(encoder, position + 24); |
| internal::WireCodingTraits<::fidl::Array<::fidl::Array<uint8_t, 5>, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_array_uint8, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::VectorView<uint8_t>, 5>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->array_vector_uint8, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::Array<uint8_t, 5>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_array_uint8, position + 112, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::VectorView<uint8_t>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, false>, IsRecursive>::Encode(encoder, &value->vector_vector_uint8, position + 128, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::fidl::Array<::fidl::Array<uint8_t, 5>, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::VectorView<uint8_t>, 5>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 32, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::Array<uint8_t, 5>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 112, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::VectorView<uint8_t>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, false>, IsRecursive>::Decode( |
| decoder, position + 128, recursion_depth); |
| } |
| internal::WireCheckPadding<uint64_t>(decoder, position + 24, 0xffffffffffffff00); |
| } |
| }; |
| |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::test_typesinprotocols::wire::Resource> : public std::true_type {}; |
| |
| template<> |
| struct TypeTraits<::test_typesinprotocols::wire::Resource> { |
| static constexpr uint32_t kMaxNumHandles = 4294967295; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 456; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::Resource> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::Resource> : public std::true_type {}; |
| template <> |
| struct IsStruct<::test_typesinprotocols::wire::Resource> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::Resource>); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, handle) == 0); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vmo) == 4); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, client_end) == 8); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, server_end) == 12); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, struct_) == 16); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, table) == 24); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, union_) == 40); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, opt_handle) == 56); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, opt_vmo) == 60); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, opt_client_end) == 64); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, opt_server_end) == 68); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, opt_struct) == 72); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, opt_union) == 80); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, array_handle) == 96); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, array_vmo) == 116); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, array_client_end) == 136); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, array_server_end) == 156); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, array_struct) == 176); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, array_table) == 184); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, array_union) == 264); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vector_handle) == 344); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vector_vmo) == 360); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vector_client_end) == 376); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vector_server_end) == 392); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vector_struct) == 408); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vector_table) == 424); |
| static_assert(offsetof(::test_typesinprotocols::wire::Resource, vector_union) == 440); |
| static_assert(sizeof(::test_typesinprotocols::wire::Resource) == TypeTraits<::test_typesinprotocols::wire::Resource>::kPrimarySize); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Resource, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> { |
| static constexpr size_t kInlineSize = 456; |
| static constexpr auto kMembers = std::make_tuple(::fidl::internal::WireStructMemberCodingInfo<::zx::handle, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::zx::vmo, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::ResourceStruct, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::ResourceTable, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::test_typesinprotocols::wire::ResourceUnion, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::zx::handle, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::zx::vmo, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::ObjectView<::test_typesinprotocols::wire::ResourceStruct>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::WireOptional<::test_typesinprotocols::wire::ResourceUnion>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::zx::handle, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::zx::vmo, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::ResourceStruct, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::ResourceTable, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::Array<::test_typesinprotocols::wire::ResourceUnion, 5>, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::zx::handle>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::zx::vmo>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::ClientEnd<::test_typesinprotocols::Protocol>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::fidl::ServerEnd<::test_typesinprotocols::Protocol>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::ResourceStruct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::ResourceTable>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>(), ::fidl::internal::WireStructMemberCodingInfo<::fidl::VectorView<::test_typesinprotocols::wire::ResourceUnion>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<false>, false>, IsRecursive>()); |
| static constexpr bool kHasPadding = true; |
| using Base = WireStructCodingTraitsBase<::test_typesinprotocols::wire::Resource, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive>; |
| static constexpr bool kIsMemcpyCompatible = Base::kIsMemcpyCompatible; |
| |
| static void Encode( |
| internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Resource* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (kIsMemcpyCompatible) { |
| memcpy(position.As<void>(), value, sizeof(::test_typesinprotocols::wire::Resource)); |
| } else { |
| internal::WireZeroPadding<uint64_t>(encoder, position + 16); |
| internal::WireZeroPadding<uint64_t>(encoder, position + 176); |
| internal::WireCodingTraits<::zx::handle, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, IsRecursive>::Encode(encoder, &value->handle, position + 0, recursion_depth); |
| internal::WireCodingTraits<::zx::vmo, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, IsRecursive>::Encode(encoder, &value->vmo, position + 4, recursion_depth); |
| internal::WireCodingTraits<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Encode(encoder, &value->client_end, position + 8, recursion_depth); |
| internal::WireCodingTraits<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Encode(encoder, &value->server_end, position + 12, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceStruct, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->struct_, position + 16, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceTable, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->table, position + 24, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceUnion, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Encode(encoder, &value->union_, position + 40, recursion_depth); |
| internal::WireCodingTraits<::zx::handle, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, true>, IsRecursive>::Encode(encoder, &value->opt_handle, position + 56, recursion_depth); |
| internal::WireCodingTraits<::zx::vmo, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, true>, IsRecursive>::Encode(encoder, &value->opt_vmo, position + 60, recursion_depth); |
| internal::WireCodingTraits<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>, IsRecursive>::Encode(encoder, &value->opt_client_end, position + 64, recursion_depth); |
| internal::WireCodingTraits<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>, IsRecursive>::Encode(encoder, &value->opt_server_end, position + 68, recursion_depth); |
| internal::WireCodingTraits<::fidl::ObjectView<::test_typesinprotocols::wire::ResourceStruct>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->opt_struct, position + 72, recursion_depth); |
| internal::WireCodingTraits<::fidl::WireOptional<::test_typesinprotocols::wire::ResourceUnion>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>::Encode(encoder, &value->opt_union, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::zx::handle, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, IsRecursive>::Encode(encoder, &value->array_handle, position + 96, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::zx::vmo, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, IsRecursive>::Encode(encoder, &value->array_vmo, position + 116, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Encode(encoder, &value->array_client_end, position + 136, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Encode(encoder, &value->array_server_end, position + 156, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::ResourceStruct, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_struct, position + 176, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::ResourceTable, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Encode(encoder, &value->array_table, position + 184, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::ResourceUnion, 5>, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Encode(encoder, &value->array_union, position + 264, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::zx::handle>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, false>, IsRecursive>::Encode(encoder, &value->vector_handle, position + 344, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::zx::vmo>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, false>, IsRecursive>::Encode(encoder, &value->vector_vmo, position + 360, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ClientEnd<::test_typesinprotocols::Protocol>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, false>, IsRecursive>::Encode(encoder, &value->vector_client_end, position + 376, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ServerEnd<::test_typesinprotocols::Protocol>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, false>, IsRecursive>::Encode(encoder, &value->vector_server_end, position + 392, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::ResourceStruct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_struct, position + 408, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::ResourceTable>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Encode(encoder, &value->vector_table, position + 424, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::ResourceUnion>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<false>, false>, IsRecursive>::Encode(encoder, &value->vector_union, position + 440, recursion_depth); |
| } |
| } |
| static void Decode( |
| internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| if constexpr (!Base::are_members_memcpy_compatible) { |
| internal::WireCodingTraits<::zx::handle, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, IsRecursive>::Decode( |
| decoder, position + 0, recursion_depth); |
| internal::WireCodingTraits<::zx::vmo, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, IsRecursive>::Decode( |
| decoder, position + 4, recursion_depth); |
| internal::WireCodingTraits<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Decode( |
| decoder, position + 8, recursion_depth); |
| internal::WireCodingTraits<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Decode( |
| decoder, position + 12, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceStruct, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 16, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceTable, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 24, recursion_depth); |
| internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceUnion, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Decode( |
| decoder, position + 40, recursion_depth); |
| internal::WireCodingTraits<::zx::handle, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, true>, IsRecursive>::Decode( |
| decoder, position + 56, recursion_depth); |
| internal::WireCodingTraits<::zx::vmo, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, true>, IsRecursive>::Decode( |
| decoder, position + 60, recursion_depth); |
| internal::WireCodingTraits<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>, IsRecursive>::Decode( |
| decoder, position + 64, recursion_depth); |
| internal::WireCodingTraits<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, true>, IsRecursive>::Decode( |
| decoder, position + 68, recursion_depth); |
| internal::WireCodingTraits<::fidl::ObjectView<::test_typesinprotocols::wire::ResourceStruct>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 72, recursion_depth); |
| internal::WireCodingTraits<::fidl::WireOptional<::test_typesinprotocols::wire::ResourceUnion>, fidl::internal::WireCodingConstraintUnion<true>, IsRecursive>::Decode( |
| decoder, position + 80, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::zx::handle, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, IsRecursive>::Decode( |
| decoder, position + 96, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::zx::vmo, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, IsRecursive>::Decode( |
| decoder, position + 116, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::ClientEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Decode( |
| decoder, position + 136, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::fidl::ServerEnd<::test_typesinprotocols::Protocol>, 5>, fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, IsRecursive>::Decode( |
| decoder, position + 156, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::ResourceStruct, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 176, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::ResourceTable, 5>, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::Decode( |
| decoder, position + 184, recursion_depth); |
| internal::WireCodingTraits<::fidl::Array<::test_typesinprotocols::wire::ResourceUnion, 5>, fidl::internal::WireCodingConstraintUnion<false>, IsRecursive>::Decode( |
| decoder, position + 264, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::zx::handle>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_NONE, 0x80000000, false>, false>, IsRecursive>::Decode( |
| decoder, position + 344, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::zx::vmo>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_VMO, 0x80000000, false>, false>, IsRecursive>::Decode( |
| decoder, position + 360, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ClientEnd<::test_typesinprotocols::Protocol>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, false>, IsRecursive>::Decode( |
| decoder, position + 376, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::fidl::ServerEnd<::test_typesinprotocols::Protocol>>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintHandle<ZX_OBJ_TYPE_CHANNEL, ZX_DEFAULT_CHANNEL_RIGHTS, false>, false>, IsRecursive>::Decode( |
| decoder, position + 392, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::ResourceStruct>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 408, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::ResourceTable>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintEmpty, false>, IsRecursive>::Decode( |
| decoder, position + 424, recursion_depth); |
| internal::WireCodingTraits<::fidl::VectorView<::test_typesinprotocols::wire::ResourceUnion>, fidl::internal::WireCodingConstraintVector<fidl::internal::WireCodingConstraintUnion<false>, false>, IsRecursive>::Decode( |
| decoder, position + 440, recursion_depth); |
| } |
| internal::WireCheckPadding<uint64_t>(decoder, position + 16, 0xffffffffffffff00); |
| internal::WireCheckPadding<uint64_t>(decoder, position + 176, 0xffffff0000000000); |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::Table> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::Table> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::Table> : public std::true_type {}; |
| template <> |
| struct IsTable<::test_typesinprotocols::wire::Table> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::Table>); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Table, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : ::fidl::internal::WireTableCodingTraitsBase<IsRecursive> { |
| using Base = ::fidl::internal::WireTableCodingTraitsBase<IsRecursive>; |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Table* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 2); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| ::fidl::internal::WirePosition vector_position; |
| if (Base::PreworkResult::kEarlyExit == |
| Base::PrepareForBodyEncode(encoder, value, position, &vector_position)) { |
| return; |
| } |
| |
| fidl_vector_t* vec = reinterpret_cast<fidl_vector_t*>(value); |
| fidl_envelope_t* envelopes = static_cast<fidl_envelope_t*>(vec->data); |
| for (size_t i = 0; i < vec->count; i++) { |
| |
| size_t encode_inline_size = 0; |
| switch (i) { |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn = nullptr; |
| switch (i) { |
| } |
| WirePosition envelope_position = vector_position + i * sizeof(fidl_envelope_t); |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &envelopes[i], envelope_position, inner_depth); |
| } |
| } |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 2); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| ::fidl::internal::WirePosition vector_position; |
| if (Base::PreworkResult::kEarlyExit == Base::DecodePrework(decoder, position, &vector_position)) { |
| return; |
| } |
| |
| fidl_vector_t* vec = position.As<fidl_vector_t>(); |
| for (size_t i = 0; i < vec->count; i++) { |
| |
| size_t decode_inline_size = 0; |
| switch (i) { |
| } |
| DecodeFn<IsRecursive> decode_fn = nullptr; |
| switch(i) { |
| } |
| ::fidl::internal::WireDecodeOptionalEnvelope(decode_inline_size, decode_fn, decoder, vector_position + i * sizeof(fidl_envelope_t), inner_depth); |
| } |
| } |
| }; |
| |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::test_typesinprotocols::wire::ResourceTable> : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ResourceTable> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ResourceTable> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ResourceTable> : public std::true_type {}; |
| template <> |
| struct IsTable<::test_typesinprotocols::wire::ResourceTable> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ResourceTable>); |
| |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceTable, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : ::fidl::internal::WireTableCodingTraitsBase<IsRecursive> { |
| using Base = ::fidl::internal::WireTableCodingTraitsBase<IsRecursive>; |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ResourceTable* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 2); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| ::fidl::internal::WirePosition vector_position; |
| if (Base::PreworkResult::kEarlyExit == |
| Base::PrepareForBodyEncode(encoder, value, position, &vector_position)) { |
| return; |
| } |
| |
| fidl_vector_t* vec = reinterpret_cast<fidl_vector_t*>(value); |
| fidl_envelope_t* envelopes = static_cast<fidl_envelope_t*>(vec->data); |
| for (size_t i = 0; i < vec->count; i++) { |
| |
| size_t encode_inline_size = 0; |
| switch (i) { |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn = nullptr; |
| switch (i) { |
| } |
| WirePosition envelope_position = vector_position + i * sizeof(fidl_envelope_t); |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &envelopes[i], envelope_position, inner_depth); |
| } |
| } |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 2); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| ::fidl::internal::WirePosition vector_position; |
| if (Base::PreworkResult::kEarlyExit == Base::DecodePrework(decoder, position, &vector_position)) { |
| return; |
| } |
| |
| fidl_vector_t* vec = position.As<fidl_vector_t>(); |
| for (size_t i = 0; i < vec->count; i++) { |
| |
| size_t decode_inline_size = 0; |
| switch (i) { |
| } |
| DecodeFn<IsRecursive> decode_fn = nullptr; |
| switch(i) { |
| } |
| ::fidl::internal::WireDecodeOptionalEnvelope(decode_inline_size, decode_fn, decoder, vector_position + i * sizeof(fidl_envelope_t), inner_depth); |
| } |
| } |
| }; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::Union> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::Union> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::Union> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::Union> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::Union>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Union, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::Union* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::Union::Tag::kB |
| encode_inline_size = ::fidl::internal::WireCodingTraits<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::Union::Tag::kB |
| encode_fn = ::fidl::internal::MakeEncodeFn<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::Union::Tag tag = *position.As<::test_typesinprotocols::wire::Union::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::Union::Tag::kB: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::Union::Tag::kB: |
| decode_fn = ::fidl::internal::MakeDecodeFn<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeFlexibleEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Union, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Union, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::test_typesinprotocols::wire::ResourceUnion> : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ResourceUnion> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 1; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 0; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ResourceUnion> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ResourceUnion> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ResourceUnion> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ResourceUnion>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceUnion, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ResourceUnion* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ResourceUnion::Tag::kB |
| encode_inline_size = ::fidl::internal::WireCodingTraits<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ResourceUnion::Tag::kB |
| encode_fn = ::fidl::internal::MakeEncodeFn<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ResourceUnion::Tag tag = *position.As<::test_typesinprotocols::wire::ResourceUnion::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ResourceUnion::Tag::kB: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ResourceUnion::Tag::kB: |
| decode_fn = ::fidl::internal::MakeDecodeFn<bool, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeFlexibleEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceUnion, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ResourceUnion, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| #endif // __Fuchsia__ |
| |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorBasicResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorBasicResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorBasicResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorBasicResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorBasicResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorBasicResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorBasicResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Basic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::Basic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Basic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::Basic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorBasicResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorBasicResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorBasicResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorCompoundResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 80; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorCompoundResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorCompoundResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorCompoundResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorCompoundResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorCompoundResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorCompoundResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Compound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::Compound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Compound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::Compound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorCompoundResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorCompoundResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorCompoundResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::ArrayBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::ArrayBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayBasicResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 2; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 368; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::ArrayCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::ArrayCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayCompoundResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 3; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::VectorBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::VectorBasic, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorBasicResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 3; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::VectorCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::VectorCompound, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorCompoundResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 3; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorOptional, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::VectorOptional, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::VectorOptional, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::VectorOptional, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorVectorOptionalResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult> { |
| static constexpr uint32_t kMaxNumHandles = 0; |
| static constexpr uint32_t kMaxDepth = 3; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = false; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayVectorNested, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::ArrayVectorNested, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ArrayVectorNested, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::ArrayVectorNested, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorArrayVectorNestedResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| #ifdef __Fuchsia__ |
| template <> |
| struct IsResource<::test_typesinprotocols::wire::ProtocolErrorResourceResult> : public std::true_type {}; |
| |
| template <> |
| struct TypeTraits<::test_typesinprotocols::wire::ProtocolErrorResourceResult> { |
| static constexpr uint32_t kMaxNumHandles = 4294967295; |
| static constexpr uint32_t kMaxDepth = 3; |
| static constexpr uint32_t kPrimarySize = 16; |
| [[maybe_unused]] |
| static constexpr uint32_t kMaxOutOfLine = 4294967295; |
| static constexpr bool kHasFlexibleEnvelope = true; |
| static constexpr bool kHasPointer = true; |
| }; |
| |
| template <> |
| struct IsFidlType<::test_typesinprotocols::wire::ProtocolErrorResourceResult> : public std::true_type {}; |
| template <> |
| struct IsWire<::test_typesinprotocols::wire::ProtocolErrorResourceResult> : public std::true_type {}; |
| template <> |
| struct IsUnion<::test_typesinprotocols::wire::ProtocolErrorResourceResult> : public std::true_type {}; |
| static_assert(std::is_standard_layout_v<::test_typesinprotocols::wire::ProtocolErrorResourceResult>); |
| |
| template <typename Constraint, bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorResourceResult, Constraint, IsRecursive> { |
| static constexpr size_t kInlineSize = 16; |
| static constexpr bool kIsMemcpyCompatible = false; |
| |
| static void Encode(internal::WireEncoder* encoder, ::test_typesinprotocols::wire::ProtocolErrorResourceResult* value, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| fidl_union_t* u = reinterpret_cast<fidl_union_t*>(value); |
| |
| if (unlikely(u->tag == 0)) { |
| if constexpr (Constraint::is_optional) { |
| *position.As<fidl_union_t>() = {}; |
| return; |
| } |
| encoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(encoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| *position.As<fidl_xunion_tag_t>() = u->tag; |
| |
| |
| size_t encode_inline_size; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kResponse |
| encode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Resource, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kErr |
| encode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| encode_inline_size = 0; |
| break; |
| } |
| ::fidl::internal::EncodeFn<IsRecursive> encode_fn; |
| switch (u->tag) { |
| case 1: // ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kResponse |
| encode_fn = ::fidl::internal::MakeEncodeFn<::test_typesinprotocols::wire::Resource, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case 2: // ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kErr |
| encode_fn = ::fidl::internal::MakeEncodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| encode_fn = nullptr; |
| break; |
| } |
| WireEncodeEnvelope(encode_inline_size, encode_fn, encoder, &u->envelope, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| |
| static void Decode(internal::WireDecoder* decoder, ::fidl::internal::WirePosition position, RecursionDepth<IsRecursive> recursion_depth) { |
| ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag tag = *position.As<::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag>(); |
| if (unlikely(static_cast<uint64_t>(tag) == 0)) { |
| if constexpr (!Constraint::is_optional) { |
| decoder->SetError(kCodingErrorInvalidUnionTag); |
| return; |
| } |
| static_assert(sizeof(fidl_envelope_t) == sizeof(uint64_t)); |
| if (*(position + sizeof(fidl_xunion_tag_t)).As<uint64_t>() != 0) { |
| decoder->SetError(kCodingErrorZeroTagButNonZeroEnvelope); |
| } |
| return; |
| } |
| |
| RecursionDepth<IsRecursive> inner_depth = recursion_depth.Add(decoder, 1); |
| if (!inner_depth.IsValid()) { |
| return; |
| } |
| |
| |
| size_t decode_inline_size; |
| switch (tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kResponse: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::Resource, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kErr: |
| decode_inline_size = ::fidl::internal::WireCodingTraits<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>::kInlineSize; |
| break; |
| default: |
| decode_inline_size = 0; |
| break; |
| } |
| DecodeFn<IsRecursive> decode_fn; |
| switch(tag) { |
| case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kResponse: |
| decode_fn = ::fidl::internal::MakeDecodeFn<::test_typesinprotocols::wire::Resource, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| case ::test_typesinprotocols::wire::ProtocolErrorResourceResult::Tag::kErr: |
| decode_fn = ::fidl::internal::MakeDecodeFn<uint32_t, fidl::internal::WireCodingConstraintEmpty, IsRecursive>(); |
| break; |
| default: |
| decode_fn = nullptr; |
| break; |
| } |
| ::fidl::internal::WireDecodeStrictEnvelope(decode_inline_size, decode_fn, decoder, position + sizeof(fidl_xunion_tag_t), inner_depth); |
| } |
| }; |
| |
| // Top-level union. |
| template <bool IsRecursive> |
| struct ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorResourceResult, ::fidl::internal::WireCodingConstraintEmpty, IsRecursive> |
| : public ::fidl::internal::WireCodingTraits<::test_typesinprotocols::wire::ProtocolErrorResourceResult, ::fidl::internal::WireCodingConstraintUnion<false>, IsRecursive> {}; |
| |
| #endif // __Fuchsia__ |
| |
| |
| #pragma clang diagnostic pop |
| |
| } // namespace fidl |
| |
