| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include <lib/fidl/internal.h> |
| #include <lib/fidl/llcpp/array.h> |
| #include <lib/fidl/llcpp/buffer_allocator.h> |
| #include <lib/fidl/llcpp/buffer_then_heap_allocator.h> |
| #include <lib/fidl/llcpp/coding.h> |
| #include <lib/fidl/llcpp/envelope.h> |
| #include <lib/fidl/llcpp/errors.h> |
| #include <lib/fidl/llcpp/memory.h> |
| #include <lib/fidl/llcpp/message.h> |
| #include <lib/fidl/llcpp/message_storage.h> |
| #include <lib/fidl/llcpp/object_view.h> |
| #include <lib/fidl/llcpp/string_view.h> |
| #include <lib/fidl/llcpp/tracking_ptr.h> |
| #include <lib/fidl/llcpp/traits.h> |
| #include <lib/fidl/llcpp/vector_view.h> |
| #include <lib/fit/function.h> |
| #include <lib/stdcompat/optional.h> |
| |
| #include <algorithm> |
| #include <cstddef> |
| #include <variant> |
| #ifdef __Fuchsia__ |
| #include <lib/fidl/llcpp/client.h> |
| #include <lib/fidl/llcpp/client_end.h> |
| #include <lib/fidl/llcpp/connect_service.h> |
| #include <lib/fidl/llcpp/result.h> |
| #include <lib/fidl/llcpp/server.h> |
| #include <lib/fidl/llcpp/server_end.h> |
| #include <lib/fidl/llcpp/service_handler_interface.h> |
| #include <lib/fidl/llcpp/sync_call.h> |
| #include <lib/fidl/llcpp/transaction.h> |
| #include <lib/fidl/txn_header.h> |
| |
| #endif // __Fuchsia__ |
| #include <zircon/fidl.h> |
| |
| namespace llcpp { |
| namespace fidl { |
| namespace test { |
| namespace padding { |
| namespace wire { |
| struct Padding7ByteMiddle; |
| } // namespace wire |
| using Padding7ByteMiddle = |
| ::llcpp::fidl::test::padding::wire::Padding7ByteMiddle; |
| namespace wire { |
| struct Padding7ByteEnd; |
| } // namespace wire |
| using Padding7ByteEnd = ::llcpp::fidl::test::padding::wire::Padding7ByteEnd; |
| namespace wire { |
| struct Padding6ByteMiddle; |
| } // namespace wire |
| using Padding6ByteMiddle = |
| ::llcpp::fidl::test::padding::wire::Padding6ByteMiddle; |
| namespace wire { |
| struct Padding6ByteEnd; |
| } // namespace wire |
| using Padding6ByteEnd = ::llcpp::fidl::test::padding::wire::Padding6ByteEnd; |
| namespace wire { |
| struct Padding5ByteMiddle; |
| } // namespace wire |
| using Padding5ByteMiddle = |
| ::llcpp::fidl::test::padding::wire::Padding5ByteMiddle; |
| namespace wire { |
| struct Padding5ByteEnd; |
| } // namespace wire |
| using Padding5ByteEnd = ::llcpp::fidl::test::padding::wire::Padding5ByteEnd; |
| namespace wire { |
| struct Padding4ByteMiddle; |
| } // namespace wire |
| using Padding4ByteMiddle = |
| ::llcpp::fidl::test::padding::wire::Padding4ByteMiddle; |
| namespace wire { |
| struct Padding4ByteEnd; |
| } // namespace wire |
| using Padding4ByteEnd = ::llcpp::fidl::test::padding::wire::Padding4ByteEnd; |
| namespace wire { |
| struct Padding4ByteAlignmentLength12; |
| } // namespace wire |
| using Padding4ByteAlignmentLength12 = |
| ::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12; |
| namespace wire { |
| struct Padding3ByteMiddle; |
| } // namespace wire |
| using Padding3ByteMiddle = |
| ::llcpp::fidl::test::padding::wire::Padding3ByteMiddle; |
| namespace wire { |
| struct Padding3ByteEnd; |
| } // namespace wire |
| using Padding3ByteEnd = ::llcpp::fidl::test::padding::wire::Padding3ByteEnd; |
| namespace wire { |
| struct Padding2ByteMiddle; |
| } // namespace wire |
| using Padding2ByteMiddle = |
| ::llcpp::fidl::test::padding::wire::Padding2ByteMiddle; |
| namespace wire { |
| struct Padding2ByteEnd; |
| } // namespace wire |
| using Padding2ByteEnd = ::llcpp::fidl::test::padding::wire::Padding2ByteEnd; |
| namespace wire { |
| struct Padding2ByteAlignmentLength6; |
| } // namespace wire |
| using Padding2ByteAlignmentLength6 = |
| ::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6; |
| namespace wire { |
| struct Padding1ByteMiddle; |
| } // namespace wire |
| using Padding1ByteMiddle = |
| ::llcpp::fidl::test::padding::wire::Padding1ByteMiddle; |
| namespace wire { |
| struct Padding1ByteEnd; |
| } // namespace wire |
| using Padding1ByteEnd = ::llcpp::fidl::test::padding::wire::Padding1ByteEnd; |
| namespace wire { |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding7ByteMiddleTable; |
| |
| struct Padding7ByteMiddle { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding7ByteMiddleTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint8_t a = {}; |
| |
| uint64_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding7ByteMiddle* value) |
| : message_(bytes, byte_size, sizeof(Padding7ByteMiddle), nullptr, 0, |
| 0) { |
| message_.Encode<Padding7ByteMiddle>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding7ByteMiddle* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding7ByteMiddle>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding7ByteMiddle* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding7ByteMiddle* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding7ByteMiddle>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding7ByteMiddle>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding7ByteMiddle>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding7ByteMiddle* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding7ByteMiddle*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding7ByteEndTable; |
| |
| struct Padding7ByteEnd { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding7ByteEndTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint64_t a = {}; |
| |
| uint8_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding7ByteEnd* value) |
| : message_(bytes, byte_size, sizeof(Padding7ByteEnd), nullptr, 0, 0) { |
| message_.Encode<Padding7ByteEnd>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding7ByteEnd* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding7ByteEnd>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding7ByteEnd* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding7ByteEnd* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding7ByteEnd>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding7ByteEnd>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding7ByteEnd>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding7ByteEnd* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding7ByteEnd*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding6ByteMiddleTable; |
| |
| struct Padding6ByteMiddle { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding6ByteMiddleTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint16_t a = {}; |
| |
| uint64_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding6ByteMiddle* value) |
| : message_(bytes, byte_size, sizeof(Padding6ByteMiddle), nullptr, 0, |
| 0) { |
| message_.Encode<Padding6ByteMiddle>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding6ByteMiddle* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding6ByteMiddle>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding6ByteMiddle* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding6ByteMiddle* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding6ByteMiddle>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding6ByteMiddle>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding6ByteMiddle>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding6ByteMiddle* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding6ByteMiddle*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding6ByteEndTable; |
| |
| struct Padding6ByteEnd { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding6ByteEndTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint64_t a = {}; |
| |
| uint16_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding6ByteEnd* value) |
| : message_(bytes, byte_size, sizeof(Padding6ByteEnd), nullptr, 0, 0) { |
| message_.Encode<Padding6ByteEnd>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding6ByteEnd* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding6ByteEnd>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding6ByteEnd* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding6ByteEnd* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding6ByteEnd>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding6ByteEnd>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding6ByteEnd>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding6ByteEnd* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding6ByteEnd*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding5ByteMiddleTable; |
| |
| struct Padding5ByteMiddle { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding5ByteMiddleTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint16_t a = {}; |
| |
| uint8_t b = {}; |
| |
| uint64_t c = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding5ByteMiddle* value) |
| : message_(bytes, byte_size, sizeof(Padding5ByteMiddle), nullptr, 0, |
| 0) { |
| message_.Encode<Padding5ByteMiddle>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding5ByteMiddle* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding5ByteMiddle>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding5ByteMiddle* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding5ByteMiddle* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding5ByteMiddle>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding5ByteMiddle>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding5ByteMiddle>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding5ByteMiddle* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding5ByteMiddle*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding5ByteEndTable; |
| |
| struct Padding5ByteEnd { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding5ByteEndTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint64_t a = {}; |
| |
| uint16_t b = {}; |
| |
| uint8_t c = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding5ByteEnd* value) |
| : message_(bytes, byte_size, sizeof(Padding5ByteEnd), nullptr, 0, 0) { |
| message_.Encode<Padding5ByteEnd>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding5ByteEnd* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding5ByteEnd>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding5ByteEnd* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding5ByteEnd* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding5ByteEnd>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding5ByteEnd>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding5ByteEnd>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding5ByteEnd* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding5ByteEnd*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding4ByteMiddleTable; |
| |
| struct Padding4ByteMiddle { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding4ByteMiddleTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint32_t a = {}; |
| |
| uint64_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding4ByteMiddle* value) |
| : message_(bytes, byte_size, sizeof(Padding4ByteMiddle), nullptr, 0, |
| 0) { |
| message_.Encode<Padding4ByteMiddle>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding4ByteMiddle* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding4ByteMiddle>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding4ByteMiddle* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding4ByteMiddle* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding4ByteMiddle>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding4ByteMiddle>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding4ByteMiddle>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding4ByteMiddle* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding4ByteMiddle*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding4ByteEndTable; |
| |
| struct Padding4ByteEnd { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding4ByteEndTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 16; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint64_t a = {}; |
| |
| uint32_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding4ByteEnd* value) |
| : message_(bytes, byte_size, sizeof(Padding4ByteEnd), nullptr, 0, 0) { |
| message_.Encode<Padding4ByteEnd>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding4ByteEnd* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding4ByteEnd>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding4ByteEnd* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding4ByteEnd* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding4ByteEnd>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding4ByteEnd>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding4ByteEnd>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding4ByteEnd* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding4ByteEnd*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t |
| fidl_test_padding_Padding4ByteAlignmentLength12Table; |
| |
| struct Padding4ByteAlignmentLength12 { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding4ByteAlignmentLength12Table; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 12; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint32_t a = {}; |
| |
| uint8_t b = {}; |
| |
| uint16_t c = {}; |
| |
| uint16_t d = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding4ByteAlignmentLength12* value) |
| : message_(bytes, byte_size, sizeof(Padding4ByteAlignmentLength12), |
| nullptr, 0, 0) { |
| message_.Encode<Padding4ByteAlignmentLength12>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding4ByteAlignmentLength12* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding4ByteAlignmentLength12>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding4ByteAlignmentLength12* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding4ByteAlignmentLength12* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding4ByteAlignmentLength12>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding4ByteAlignmentLength12>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding4ByteAlignmentLength12>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding4ByteAlignmentLength12* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding4ByteAlignmentLength12*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding3ByteMiddleTable; |
| |
| struct Padding3ByteMiddle { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding3ByteMiddleTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 8; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint8_t a = {}; |
| |
| uint32_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding3ByteMiddle* value) |
| : message_(bytes, byte_size, sizeof(Padding3ByteMiddle), nullptr, 0, |
| 0) { |
| message_.Encode<Padding3ByteMiddle>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding3ByteMiddle* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding3ByteMiddle>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding3ByteMiddle* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding3ByteMiddle* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding3ByteMiddle>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding3ByteMiddle>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding3ByteMiddle>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding3ByteMiddle* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding3ByteMiddle*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding3ByteEndTable; |
| |
| struct Padding3ByteEnd { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding3ByteEndTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 8; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint32_t a = {}; |
| |
| uint8_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding3ByteEnd* value) |
| : message_(bytes, byte_size, sizeof(Padding3ByteEnd), nullptr, 0, 0) { |
| message_.Encode<Padding3ByteEnd>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding3ByteEnd* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding3ByteEnd>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding3ByteEnd* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding3ByteEnd* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding3ByteEnd>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding3ByteEnd>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding3ByteEnd>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding3ByteEnd* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding3ByteEnd*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding2ByteMiddleTable; |
| |
| struct Padding2ByteMiddle { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding2ByteMiddleTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 8; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint16_t a = {}; |
| |
| uint32_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding2ByteMiddle* value) |
| : message_(bytes, byte_size, sizeof(Padding2ByteMiddle), nullptr, 0, |
| 0) { |
| message_.Encode<Padding2ByteMiddle>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding2ByteMiddle* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding2ByteMiddle>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding2ByteMiddle* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding2ByteMiddle* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding2ByteMiddle>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding2ByteMiddle>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding2ByteMiddle>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding2ByteMiddle* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding2ByteMiddle*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding2ByteEndTable; |
| |
| struct Padding2ByteEnd { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding2ByteEndTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 8; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint32_t a = {}; |
| |
| uint16_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding2ByteEnd* value) |
| : message_(bytes, byte_size, sizeof(Padding2ByteEnd), nullptr, 0, 0) { |
| message_.Encode<Padding2ByteEnd>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding2ByteEnd* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding2ByteEnd>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding2ByteEnd* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding2ByteEnd* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding2ByteEnd>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding2ByteEnd>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding2ByteEnd>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding2ByteEnd* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding2ByteEnd*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t |
| fidl_test_padding_Padding2ByteAlignmentLength6Table; |
| |
| struct Padding2ByteAlignmentLength6 { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding2ByteAlignmentLength6Table; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 6; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint8_t a = {}; |
| |
| uint16_t b = {}; |
| |
| uint8_t c = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding2ByteAlignmentLength6* value) |
| : message_(bytes, byte_size, sizeof(Padding2ByteAlignmentLength6), |
| nullptr, 0, 0) { |
| message_.Encode<Padding2ByteAlignmentLength6>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding2ByteAlignmentLength6* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding2ByteAlignmentLength6>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding2ByteAlignmentLength6* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding2ByteAlignmentLength6* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding2ByteAlignmentLength6>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding2ByteAlignmentLength6>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding2ByteAlignmentLength6>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding2ByteAlignmentLength6* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding2ByteAlignmentLength6*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding1ByteMiddleTable; |
| |
| struct Padding1ByteMiddle { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding1ByteMiddleTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 4; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint8_t a = {}; |
| |
| uint16_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding1ByteMiddle* value) |
| : message_(bytes, byte_size, sizeof(Padding1ByteMiddle), nullptr, 0, |
| 0) { |
| message_.Encode<Padding1ByteMiddle>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding1ByteMiddle* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding1ByteMiddle>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding1ByteMiddle* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding1ByteMiddle* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding1ByteMiddle>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding1ByteMiddle>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding1ByteMiddle>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding1ByteMiddle* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding1ByteMiddle*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| extern "C" const fidl_type_t fidl_test_padding_Padding1ByteEndTable; |
| |
| struct Padding1ByteEnd { |
| static constexpr const fidl_type_t* Type = |
| &fidl_test_padding_Padding1ByteEndTable; |
| static constexpr uint32_t MaxNumHandles = 0; |
| static constexpr uint32_t PrimarySize = 4; |
| [[maybe_unused]] static constexpr uint32_t MaxOutOfLine = 0; |
| static constexpr bool HasPointer = false; |
| |
| uint16_t a = {}; |
| |
| uint8_t b = {}; |
| |
| private: |
| class UnownedEncodedByteMessage final { |
| public: |
| UnownedEncodedByteMessage(uint8_t* bytes, uint32_t byte_size, |
| Padding1ByteEnd* value) |
| : message_(bytes, byte_size, sizeof(Padding1ByteEnd), nullptr, 0, 0) { |
| message_.Encode<Padding1ByteEnd>(value); |
| } |
| UnownedEncodedByteMessage(const UnownedEncodedByteMessage&) = delete; |
| UnownedEncodedByteMessage(UnownedEncodedByteMessage&&) = delete; |
| UnownedEncodedByteMessage* operator=(const UnownedEncodedByteMessage&) = |
| delete; |
| UnownedEncodedByteMessage* operator=(UnownedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingByteMessage message_; |
| }; |
| |
| class UnownedEncodedIovecMessage final { |
| public: |
| UnownedEncodedIovecMessage(zx_channel_iovec_t* iovecs, uint32_t iovec_size, |
| fidl_iovec_substitution_t* substitutions, |
| uint32_t substitutions_size, |
| Padding1ByteEnd* value) |
| : message_(::fidl::OutgoingIovecMessage::constructor_args{ |
| .iovecs = iovecs, |
| .iovecs_actual = 0, |
| .iovecs_capacity = iovec_size, |
| .substitutions = substitutions, |
| .substitutions_actual = 0, |
| .substitutions_capacity = substitutions_size, |
| .handles = nullptr, |
| .handle_actual = 0, |
| .handle_capacity = 0, |
| }) { |
| message_.Encode<Padding1ByteEnd>(value); |
| } |
| UnownedEncodedIovecMessage(const UnownedEncodedIovecMessage&) = delete; |
| UnownedEncodedIovecMessage(UnownedEncodedIovecMessage&&) = delete; |
| UnownedEncodedIovecMessage* operator=(const UnownedEncodedIovecMessage&) = |
| delete; |
| UnownedEncodedIovecMessage* operator=(UnownedEncodedIovecMessage&&) = |
| delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.status() == ZX_OK; } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { return message_; } |
| |
| private: |
| ::fidl::OutgoingIovecMessage message_; |
| }; |
| |
| class OwnedEncodedByteMessage final { |
| public: |
| explicit OwnedEncodedByteMessage(Padding1ByteEnd* value) |
| : message_(bytes_, sizeof(bytes_), value) {} |
| OwnedEncodedByteMessage(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage(OwnedEncodedByteMessage&&) = delete; |
| OwnedEncodedByteMessage* operator=(const OwnedEncodedByteMessage&) = delete; |
| OwnedEncodedByteMessage* operator=(OwnedEncodedByteMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingByteMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| FIDL_ALIGNDECL |
| uint8_t bytes_[FIDL_ALIGN(PrimarySize + MaxOutOfLine)]; |
| UnownedEncodedByteMessage message_; |
| }; |
| |
| class OwnedEncodedIovecMessage final { |
| public: |
| explicit OwnedEncodedIovecMessage(Padding1ByteEnd* value) |
| : message_(iovecs_, ::fidl::internal::kIovecBufferSize, substitutions_, |
| ::fidl::internal::kIovecBufferSize, value) {} |
| OwnedEncodedIovecMessage(const OwnedEncodedIovecMessage&) = delete; |
| OwnedEncodedIovecMessage(OwnedEncodedIovecMessage&&) = delete; |
| OwnedEncodedIovecMessage* operator=(const OwnedEncodedIovecMessage&) = |
| delete; |
| OwnedEncodedIovecMessage* operator=(OwnedEncodedIovecMessage&&) = delete; |
| |
| zx_status_t status() const { return message_.status(); } |
| #ifdef __Fuchsia__ |
| const char* status_string() const { return message_.status_string(); } |
| #endif |
| bool ok() const { return message_.ok(); } |
| const char* error() const { return message_.error(); } |
| |
| ::fidl::OutgoingIovecMessage& GetOutgoingMessage() { |
| return message_.GetOutgoingMessage(); |
| } |
| |
| private: |
| zx_channel_iovec_t iovecs_[::fidl::internal::kIovecBufferSize]; |
| fidl_iovec_substitution_t |
| substitutions_[::fidl::internal::kIovecBufferSize]; |
| UnownedEncodedIovecMessage message_; |
| }; |
| |
| public: |
| friend ::fidl::internal::EncodedMessageTypes<Padding1ByteEnd>; |
| using OwnedEncodedMessage = OwnedEncodedByteMessage; |
| using UnownedEncodedMessage = UnownedEncodedByteMessage; |
| |
| class DecodedMessage final : public ::fidl::internal::IncomingMessage { |
| public: |
| DecodedMessage(uint8_t* bytes, uint32_t byte_actual, |
| zx_handle_info_t* handles = nullptr, |
| uint32_t handle_actual = 0) |
| : ::fidl::internal::IncomingMessage(bytes, byte_actual, handles, |
| handle_actual) { |
| Decode<struct Padding1ByteEnd>(); |
| } |
| DecodedMessage(fidl_incoming_msg_t* msg) |
| : ::fidl::internal::IncomingMessage(msg) { |
| Decode<struct Padding1ByteEnd>(); |
| } |
| DecodedMessage(const DecodedMessage&) = delete; |
| DecodedMessage(DecodedMessage&&) = delete; |
| DecodedMessage* operator=(const DecodedMessage&) = delete; |
| DecodedMessage* operator=(DecodedMessage&&) = delete; |
| |
| struct Padding1ByteEnd* PrimaryObject() { |
| ZX_DEBUG_ASSERT(ok()); |
| return reinterpret_cast<struct Padding1ByteEnd*>(bytes()); |
| } |
| |
| // Release the ownership of the decoded message. That means that the handles |
| // won't be closed When the object is destroyed. After calling this method, |
| // the DecodedMessage object should not be used anymore. |
| void ReleasePrimaryObject() { ResetBytes(); } |
| }; |
| }; |
| |
| } // namespace wire |
| } // namespace padding |
| } // namespace test |
| } // namespace fidl |
| } // namespace llcpp |
| namespace fidl { |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding7ByteMiddle> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding7ByteMiddle> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding7ByteMiddle>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding7ByteMiddle, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding7ByteMiddle, |
| b) == 8); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding7ByteMiddle) == |
| ::llcpp::fidl::test::padding::wire::Padding7ByteMiddle::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding7ByteEnd> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding7ByteEnd> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding7ByteEnd>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding7ByteEnd, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding7ByteEnd, |
| b) == 8); |
| static_assert(sizeof(::llcpp::fidl::test::padding::wire::Padding7ByteEnd) == |
| ::llcpp::fidl::test::padding::wire::Padding7ByteEnd::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding6ByteMiddle> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding6ByteMiddle> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding6ByteMiddle>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding6ByteMiddle, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding6ByteMiddle, |
| b) == 8); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding6ByteMiddle) == |
| ::llcpp::fidl::test::padding::wire::Padding6ByteMiddle::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding6ByteEnd> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding6ByteEnd> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding6ByteEnd>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding6ByteEnd, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding6ByteEnd, |
| b) == 8); |
| static_assert(sizeof(::llcpp::fidl::test::padding::wire::Padding6ByteEnd) == |
| ::llcpp::fidl::test::padding::wire::Padding6ByteEnd::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding5ByteMiddle> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding5ByteMiddle> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding5ByteMiddle>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding5ByteMiddle, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding5ByteMiddle, |
| b) == 2); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding5ByteMiddle, |
| c) == 8); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding5ByteMiddle) == |
| ::llcpp::fidl::test::padding::wire::Padding5ByteMiddle::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding5ByteEnd> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding5ByteEnd> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding5ByteEnd>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding5ByteEnd, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding5ByteEnd, |
| b) == 8); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding5ByteEnd, |
| c) == 10); |
| static_assert(sizeof(::llcpp::fidl::test::padding::wire::Padding5ByteEnd) == |
| ::llcpp::fidl::test::padding::wire::Padding5ByteEnd::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding4ByteMiddle> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding4ByteMiddle> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding4ByteMiddle>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteMiddle, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteMiddle, |
| b) == 8); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding4ByteMiddle) == |
| ::llcpp::fidl::test::padding::wire::Padding4ByteMiddle::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding4ByteEnd> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding4ByteEnd> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding4ByteEnd>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteEnd, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteEnd, |
| b) == 8); |
| static_assert(sizeof(::llcpp::fidl::test::padding::wire::Padding4ByteEnd) == |
| ::llcpp::fidl::test::padding::wire::Padding4ByteEnd::PrimarySize); |
| |
| template <> |
| struct IsFidlType< |
| ::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct< |
| ::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12> |
| : public std::true_type {}; |
| static_assert( |
| std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12>); |
| static_assert( |
| offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12, |
| a) == 0); |
| static_assert( |
| offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12, |
| b) == 4); |
| static_assert( |
| offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12, |
| c) == 6); |
| static_assert( |
| offsetof(::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12, |
| d) == 8); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12) == |
| ::llcpp::fidl::test::padding::wire::Padding4ByteAlignmentLength12:: |
| PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding3ByteMiddle> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding3ByteMiddle> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding3ByteMiddle>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding3ByteMiddle, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding3ByteMiddle, |
| b) == 4); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding3ByteMiddle) == |
| ::llcpp::fidl::test::padding::wire::Padding3ByteMiddle::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding3ByteEnd> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding3ByteEnd> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding3ByteEnd>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding3ByteEnd, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding3ByteEnd, |
| b) == 4); |
| static_assert(sizeof(::llcpp::fidl::test::padding::wire::Padding3ByteEnd) == |
| ::llcpp::fidl::test::padding::wire::Padding3ByteEnd::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding2ByteMiddle> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding2ByteMiddle> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding2ByteMiddle>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding2ByteMiddle, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding2ByteMiddle, |
| b) == 4); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding2ByteMiddle) == |
| ::llcpp::fidl::test::padding::wire::Padding2ByteMiddle::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding2ByteEnd> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding2ByteEnd> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding2ByteEnd>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding2ByteEnd, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding2ByteEnd, |
| b) == 4); |
| static_assert(sizeof(::llcpp::fidl::test::padding::wire::Padding2ByteEnd) == |
| ::llcpp::fidl::test::padding::wire::Padding2ByteEnd::PrimarySize); |
| |
| template <> |
| struct IsFidlType< |
| ::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct< |
| ::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6> |
| : public std::true_type {}; |
| static_assert( |
| std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6>); |
| static_assert( |
| offsetof(::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6, |
| a) == 0); |
| static_assert( |
| offsetof(::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6, |
| b) == 2); |
| static_assert( |
| offsetof(::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6, |
| c) == 4); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6) == |
| ::llcpp::fidl::test::padding::wire::Padding2ByteAlignmentLength6:: |
| PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding1ByteMiddle> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding1ByteMiddle> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding1ByteMiddle>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding1ByteMiddle, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding1ByteMiddle, |
| b) == 2); |
| static_assert( |
| sizeof(::llcpp::fidl::test::padding::wire::Padding1ByteMiddle) == |
| ::llcpp::fidl::test::padding::wire::Padding1ByteMiddle::PrimarySize); |
| |
| template <> |
| struct IsFidlType<::llcpp::fidl::test::padding::wire::Padding1ByteEnd> |
| : public std::true_type {}; |
| template <> |
| struct IsStruct<::llcpp::fidl::test::padding::wire::Padding1ByteEnd> |
| : public std::true_type {}; |
| static_assert(std::is_standard_layout_v< |
| ::llcpp::fidl::test::padding::wire::Padding1ByteEnd>); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding1ByteEnd, |
| a) == 0); |
| static_assert(offsetof(::llcpp::fidl::test::padding::wire::Padding1ByteEnd, |
| b) == 2); |
| static_assert(sizeof(::llcpp::fidl::test::padding::wire::Padding1ByteEnd) == |
| ::llcpp::fidl::test::padding::wire::Padding1ByteEnd::PrimarySize); |
| } // namespace fidl |
| namespace llcpp { |
| namespace fidl { |
| namespace test { |
| namespace padding { |
| namespace wire {} // namespace wire |
| } // namespace padding |
| } // namespace test |
| } // namespace fidl |
| } // namespace llcpp |
