| // WARNING: This file is machine generated by fidlgen. |
| |
| #pragma once |
| |
| #include "lib/fidl/cpp/internal/header.h" |
| |
| // |
| // Domain objects declarations (i.e. "natural types" in unified bindings). |
| // |
| namespace fidl { |
| namespace test { |
| namespace emptystruct { |
| class Empty; |
| |
| #ifdef __Fuchsia__ |
| |
| class EmptyProtocol; |
| using EmptyProtocolHandle = ::fidl::InterfaceHandle<EmptyProtocol>; |
| #endif // __Fuchsia__ |
| |
| class Empty final { |
| public: |
| static const fidl_type_t* FidlType; |
| |
| uint8_t __reserved = 0u; |
| |
| static inline ::std::unique_ptr<Empty> New() { |
| return ::std::make_unique<Empty>(); |
| } |
| |
| void Encode(::fidl::Encoder* _encoder, size_t _offset, |
| cpp17::optional<::fidl::HandleInformation> maybe_handle_info = |
| cpp17::nullopt); |
| static void Decode(::fidl::Decoder* _decoder, Empty* value, size_t _offset); |
| zx_status_t Clone(Empty* result) const; |
| }; |
| |
| inline zx_status_t Clone(const ::fidl::test::emptystruct::Empty& _value, |
| ::fidl::test::emptystruct::Empty* _result) { |
| return _value.Clone(_result); |
| } |
| |
| using EmptyPtr = ::std::unique_ptr<Empty>; |
| |
| #ifdef __Fuchsia__ |
| |
| namespace _internal { |
| extern "C" const fidl_type_t |
| fidl_test_emptystruct_EmptyProtocolSendRequestTable; |
| |
| extern "C" const fidl_type_t |
| fidl_test_emptystruct_EmptyProtocolSendAndReceiveRequestTable; |
| |
| } // namespace _internal |
| class EmptyProtocol_RequestEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage Send( |
| ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(24 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, e, 16); |
| |
| fidl_trace(DidHLCPPEncode, |
| &::fidl::test::emptystruct::_internal:: |
| fidl_test_emptystruct_EmptyProtocolSendRequestTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage SendAndReceive( |
| ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(24 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, e, 16); |
| |
| fidl_trace( |
| DidHLCPPEncode, |
| &::fidl::test::emptystruct::_internal:: |
| fidl_test_emptystruct_EmptyProtocolSendAndReceiveRequestTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| |
| return _encoder->GetMessage(); |
| } |
| }; |
| namespace _internal { |
| extern "C" const fidl_type_t |
| fidl_test_emptystruct_EmptyProtocolReceiveEventTable; |
| |
| extern "C" const fidl_type_t |
| fidl_test_emptystruct_EmptyProtocolSendAndReceiveResponseTable; |
| |
| } // namespace _internal |
| class EmptyProtocol_ResponseEncoder { |
| public: |
| static ::fidl::HLCPPOutgoingMessage Receive( |
| ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(24 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, e, 16); |
| |
| fidl_trace(DidHLCPPEncode, |
| &::fidl::test::emptystruct::_internal:: |
| fidl_test_emptystruct_EmptyProtocolReceiveEventTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| return _encoder->GetMessage(); |
| } |
| static ::fidl::HLCPPOutgoingMessage SendAndReceive( |
| ::fidl::Encoder* _encoder, ::fidl::test::emptystruct::Empty* e) { |
| fidl_trace(WillHLCPPEncode); |
| _encoder->Alloc(24 - sizeof(fidl_message_header_t)); |
| ::fidl::Encode(_encoder, e, 16); |
| |
| fidl_trace( |
| DidHLCPPEncode, |
| &::fidl::test::emptystruct::_internal:: |
| fidl_test_emptystruct_EmptyProtocolSendAndReceiveResponseTable, |
| _encoder->GetPtr<const char>(0), _encoder->CurrentLength(), |
| _encoder->CurrentHandleCount()); |
| return _encoder->GetMessage(); |
| } |
| }; |
| #endif // __Fuchsia__ |
| |
| } // namespace emptystruct |
| } // namespace test |
| template <> |
| struct CodingTraits<::fidl::test::emptystruct::Empty> |
| : public EncodableCodingTraits<::fidl::test::emptystruct::Empty, 1> {}; |
| |
| template <> |
| struct IsMemcpyCompatible<::fidl::test::emptystruct::Empty> |
| : public internal::BoolConstant< |
| !HasPadding<::fidl::test::emptystruct::Empty>::value && |
| IsMemcpyCompatible<uint8_t>::value> {}; |
| |
| inline zx_status_t Clone(const ::fidl::test::emptystruct::Empty& value, |
| ::fidl::test::emptystruct::Empty* result) { |
| return ::fidl::test::emptystruct::Clone(value, result); |
| } |
| |
| template <> |
| struct Equality<::fidl::test::emptystruct::Empty> { |
| bool operator()(const ::fidl::test::emptystruct::Empty& _lhs, |
| const ::fidl::test::emptystruct::Empty& _rhs) const { |
| if (!::fidl::Equals(_lhs.__reserved, _rhs.__reserved)) { |
| return false; |
| } |
| return true; |
| } |
| }; |
| |
| // |
| // Proxies and stubs declarations |
| // |
| namespace test { |
| namespace emptystruct { |
| #ifdef __Fuchsia__ |
| |
| using EmptyProtocolPtr = ::fidl::InterfacePtr<EmptyProtocol>; |
| class EmptyProtocol_Proxy; |
| class EmptyProtocol_Stub; |
| class EmptyProtocol_EventSender; |
| class EmptyProtocol_Sync; |
| using EmptyProtocolSyncPtr = ::fidl::SynchronousInterfacePtr<EmptyProtocol>; |
| class EmptyProtocol_SyncProxy; |
| |
| namespace internal { |
| constexpr uint64_t kEmptyProtocol_Send_Ordinal = 0x1e4e78d0556b6f28lu; |
| constexpr uint64_t kEmptyProtocol_Receive_Ordinal = 0x45bd261c537791e0lu; |
| constexpr uint64_t kEmptyProtocol_SendAndReceive_Ordinal = 0x56ca6bd78bac3571lu; |
| } // namespace internal |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| class EmptyProtocol { |
| public: |
| using Proxy_ = ::fidl::test::emptystruct::EmptyProtocol_Proxy; |
| using Stub_ = ::fidl::test::emptystruct::EmptyProtocol_Stub; |
| using EventSender_ = ::fidl::test::emptystruct::EmptyProtocol_EventSender; |
| using Sync_ = ::fidl::test::emptystruct::EmptyProtocol_Sync; |
| virtual ~EmptyProtocol(); |
| |
| virtual void Send(::fidl::test::emptystruct::Empty e) = 0; |
| using ReceiveCallback = fit::function<void(::fidl::test::emptystruct::Empty)>; |
| using SendAndReceiveCallback = |
| fit::function<void(::fidl::test::emptystruct::Empty)>; |
| |
| virtual void SendAndReceive(::fidl::test::emptystruct::Empty e, |
| SendAndReceiveCallback callback) = 0; |
| }; |
| |
| class EmptyProtocol_RequestDecoder { |
| public: |
| EmptyProtocol_RequestDecoder() = default; |
| virtual ~EmptyProtocol_RequestDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal, bool* out_needs_response); |
| virtual void Send(::fidl::test::emptystruct::Empty e) = 0; |
| virtual void SendAndReceive(::fidl::test::emptystruct::Empty e) = 0; |
| }; |
| |
| class EmptyProtocol_ResponseDecoder { |
| public: |
| EmptyProtocol_ResponseDecoder() = default; |
| virtual ~EmptyProtocol_ResponseDecoder() = default; |
| static const fidl_type_t* GetType(uint64_t ordinal); |
| virtual void Receive(::fidl::test::emptystruct::Empty e) = 0; |
| virtual void SendAndReceive(::fidl::test::emptystruct::Empty e) = 0; |
| }; |
| |
| class EmptyProtocol_EventSender { |
| public: |
| virtual ~EmptyProtocol_EventSender(); |
| virtual void Receive(::fidl::test::emptystruct::Empty e) = 0; |
| }; |
| |
| class EmptyProtocol_Sync { |
| public: |
| using Proxy_ = ::fidl::test::emptystruct::EmptyProtocol_SyncProxy; |
| virtual ~EmptyProtocol_Sync(); |
| virtual zx_status_t Send(::fidl::test::emptystruct::Empty e) = 0; |
| virtual zx_status_t SendAndReceive( |
| ::fidl::test::emptystruct::Empty e, |
| ::fidl::test::emptystruct::Empty* out_e) = 0; |
| }; |
| |
| class EmptyProtocol_Proxy final : public ::fidl::internal::Proxy, |
| public EmptyProtocol { |
| public: |
| explicit EmptyProtocol_Proxy(::fidl::internal::ProxyController* controller); |
| ~EmptyProtocol_Proxy() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message) override; |
| void Send(::fidl::test::emptystruct::Empty e) override; |
| ReceiveCallback Receive; |
| void SendAndReceive(::fidl::test::emptystruct::Empty e, |
| SendAndReceiveCallback callback) override; |
| |
| private: |
| EmptyProtocol_Proxy(const ::fidl::test::emptystruct::EmptyProtocol_Proxy&) = |
| delete; |
| EmptyProtocol_Proxy& operator=( |
| const ::fidl::test::emptystruct::EmptyProtocol_Proxy&) = delete; |
| |
| ::fidl::internal::ProxyController* controller_; |
| }; |
| |
| class EmptyProtocol_Stub final |
| : public ::fidl::internal::Stub, |
| public ::fidl::test::emptystruct::EmptyProtocol_EventSender { |
| public: |
| typedef class ::fidl::test::emptystruct::EmptyProtocol EmptyProtocol_clazz; |
| explicit EmptyProtocol_Stub( |
| ::fidl::test::emptystruct::EmptyProtocol_Stub::EmptyProtocol_clazz* impl); |
| ~EmptyProtocol_Stub() override; |
| |
| zx_status_t Dispatch_(::fidl::HLCPPIncomingMessage message, |
| ::fidl::internal::PendingResponse response) override; |
| void Receive(::fidl::test::emptystruct::Empty e) override; |
| |
| private: |
| ::fidl::test::emptystruct::EmptyProtocol_Stub::EmptyProtocol_clazz* impl_; |
| }; |
| |
| class EmptyProtocol_SyncProxy |
| : public ::fidl::test::emptystruct::EmptyProtocol_Sync { |
| public: |
| explicit EmptyProtocol_SyncProxy(::zx::channel channel); |
| ~EmptyProtocol_SyncProxy() override; |
| zx_status_t Send(::fidl::test::emptystruct::Empty e) override; |
| zx_status_t SendAndReceive(::fidl::test::emptystruct::Empty e, |
| ::fidl::test::emptystruct::Empty* out_e) override; |
| |
| private: |
| ::fidl::internal::SynchronousProxy proxy_; |
| friend class ::fidl::SynchronousInterfacePtr<EmptyProtocol>; |
| }; |
| #endif // __Fuchsia__ |
| |
| } // namespace emptystruct |
| } // namespace test |
| } // namespace fidl |