| // WARNING: This file is machine generated by fidlgen_llcpp. |
| |
| #pragma once |
| |
| #include <fidl/test.protocols/cpp/markers.h> |
| #include <fidl/test.protocols/cpp/natural_types.h> |
| #include <fidl/test.protocols/cpp/wire_messaging.h> |
| #include <lib/fidl/cpp/channel.h> |
| #include <lib/fidl/cpp/client.h> |
| #include <lib/fidl/cpp/internal/thenable.h> |
| #include <lib/fidl/cpp/natural_types.h> |
| #include <lib/fidl/cpp/unified_messaging.h> |
| |
| namespace fidl {} // namespace fidl |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestEmptyResponse>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = true; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = true; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseNoRequestWithResponseTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestNoResponseRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestEmptyResponseRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseWithRequestWithResponseTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithAndWithoutRequestResponseOnWithResponseRequestTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| |
| template <> |
| class ::fidl::Event< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Event< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| |
| template <> |
| class ::fidl::Event< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse> |
| final : public ::test_protocols:: |
| WithAndWithoutRequestResponseOnWithResponseRequest { |
| public: |
| using ::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest:: |
| WithAndWithoutRequestResponseOnWithResponseRequest; |
| Event(::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest v) |
| : WithAndWithoutRequestResponseOnWithResponseRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Event< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = |
| ::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| |
| template <> |
| class ::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| template <> |
| class ::fidl::Result< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final : public ::fitx::result<::fidl::Error> { |
| public: |
| using ::fitx::result<::fidl::Error>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final : public ::test_protocols:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse { |
| public: |
| using ::test_protocols:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse; |
| Response(::test_protocols:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse v) |
| : WithAndWithoutRequestResponseNoRequestWithResponseTopResponse( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse; |
| }; |
| template <> |
| class ::fidl::Result< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final |
| : public ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols:: |
| WithAndWithoutRequestResponseNoRequestWithResponseTopResponse>:: |
| result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| template <> |
| class ::fidl::Result< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final : public ::fitx::result<::fidl::Error> { |
| public: |
| using ::fitx::result<::fidl::Error>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final |
| : public ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse { |
| public: |
| using ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse; |
| Response( |
| ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse v) |
| : WithAndWithoutRequestResponseWithRequestWithResponseTopResponse( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Response< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse; |
| }; |
| template <> |
| class ::fidl::Result< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final |
| : public ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseTopResponse>:: |
| result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalClientImpl< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| NoRequestEmptyResponse() const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| NoRequestWithResponse() const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| WithRequestEmptyResponse( |
| ::fidl::Request<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse> |
| request) const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| WithRequestWithResponse( |
| ::fidl::Request<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse> |
| request) const; |
| |
| ::fitx::result<::fidl::Error> NoRequestNoResponse() const; |
| |
| ::fitx::result<::fidl::Error> WithRequestNoResponse( |
| ::fidl::Request<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestNoResponse> |
| request) const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::WithAndWithoutRequestResponse> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| virtual void OnEmptyResponse( |
| ::fidl::Event<::test_protocols::WithAndWithoutRequestResponse:: |
| OnEmptyResponse>&) = 0; |
| virtual void OnWithResponse( |
| ::fidl::Event<::test_protocols::WithAndWithoutRequestResponse:: |
| OnWithResponse>&) = 0; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::WithAndWithoutRequestResponse>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| void OnEmptyResponse( |
| ::fidl::Event< |
| ::test_protocols::WithAndWithoutRequestResponse::OnEmptyResponse>&) |
| override {} |
| void OnWithResponse( |
| ::fidl::Event< |
| ::test_protocols::WithAndWithoutRequestResponse::OnWithResponse>&) |
| override {} |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler< |
| ::test_protocols::WithAndWithoutRequestResponse>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler< |
| ::test_protocols::WithAndWithoutRequestResponse>* event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| ::fitx::result<::fidl::Error> OnEmptyResponse(); |
| |
| ::fitx::result<::fidl::Error> OnWithResponse( |
| ::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest |
| payload); |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::WithAndWithoutRequestResponse>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| ::fitx::result<::fidl::Error> OnEmptyResponse(); |
| |
| ::fitx::result<::fidl::Error> OnWithResponse( |
| ::test_protocols::WithAndWithoutRequestResponseOnWithResponseRequest |
| payload); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse> |
| final : public ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest { |
| public: |
| using ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest; |
| Request(::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest v) |
| : ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestNoResponseRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| final : public ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest { |
| public: |
| using ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest; |
| Request(::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest v) |
| : ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestEmptyResponseRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| final : public ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest { |
| public: |
| using ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest; |
| Request(::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest v) |
| : ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits<::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols:: |
| WithAndWithoutRequestResponseWithRequestWithResponseRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(::fidl::Response<::test_protocols::WithAndWithoutRequestResponse:: |
| NoRequestWithResponse>&& response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestEmptyResponse> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(::fidl::Response<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestWithResponse>&& response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::Server<::test_protocols::WithAndWithoutRequestResponse> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::WithAndWithoutRequestResponse; |
| |
| using NoRequestNoResponseRequest = ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>; |
| using NoRequestNoResponseCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestNoResponse>; |
| |
| virtual void NoRequestNoResponse( |
| NoRequestNoResponseRequest& request, |
| NoRequestNoResponseCompleter::Sync& completer) = 0; |
| |
| using NoRequestEmptyResponseRequest = ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>; |
| using NoRequestEmptyResponseCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestEmptyResponse>; |
| |
| virtual void NoRequestEmptyResponse( |
| NoRequestEmptyResponseRequest& request, |
| NoRequestEmptyResponseCompleter::Sync& completer) = 0; |
| |
| using NoRequestWithResponseRequest = ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>; |
| using NoRequestWithResponseCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::NoRequestWithResponse>; |
| |
| virtual void NoRequestWithResponse( |
| NoRequestWithResponseRequest& request, |
| NoRequestWithResponseCompleter::Sync& completer) = 0; |
| |
| using WithRequestNoResponseRequest = ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>; |
| using WithRequestNoResponseCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestNoResponse>; |
| |
| virtual void WithRequestNoResponse( |
| WithRequestNoResponseRequest& request, |
| WithRequestNoResponseCompleter::Sync& completer) = 0; |
| |
| using WithRequestEmptyResponseRequest = |
| ::fidl::Request<::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>; |
| using WithRequestEmptyResponseCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse:: |
| WithRequestEmptyResponse>; |
| |
| virtual void WithRequestEmptyResponse( |
| WithRequestEmptyResponseRequest& request, |
| WithRequestEmptyResponseCompleter::Sync& completer) = 0; |
| |
| using WithRequestWithResponseRequest = ::fidl::Request< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>; |
| using WithRequestWithResponseCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithAndWithoutRequestResponse::WithRequestWithResponse>; |
| |
| virtual void WithRequestWithResponse( |
| WithRequestWithResponseRequest& request, |
| WithRequestWithResponseCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::WithAndWithoutRequestResponse> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch( |
| ::fidl::Server<::test_protocols::WithAndWithoutRequestResponse>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::Transitional::Request> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::Transitional::Request>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::Transitional::Request>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalRequestRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalRequestTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalOneWayRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_TransitionalEventRequestTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| |
| template <> |
| class ::fidl::Event<::test_protocols::Transitional::Event> final |
| : public ::test_protocols::TransitionalEventRequest { |
| public: |
| using ::test_protocols::TransitionalEventRequest::TransitionalEventRequest; |
| Event(::test_protocols::TransitionalEventRequest v) |
| : TransitionalEventRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Event<::test_protocols::Transitional::Event>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::TransitionalEventRequest; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| |
| template <> |
| class ::fidl::Response<::test_protocols::Transitional::Request> final |
| : public ::test_protocols::TransitionalRequestTopResponse { |
| public: |
| using ::test_protocols::TransitionalRequestTopResponse:: |
| TransitionalRequestTopResponse; |
| Response(::test_protocols::TransitionalRequestTopResponse v) |
| : TransitionalRequestTopResponse(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::Transitional::Request>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::TransitionalRequestTopResponse; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| template <> |
| class ::fidl::Result<::test_protocols::Transitional::Request> final |
| : public ::fitx::result<::fidl::Error, |
| ::test_protocols::TransitionalRequestTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, ::test_protocols::TransitionalRequestTopResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalClientImpl<::test_protocols::Transitional> final |
| : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fidl::internal::NaturalThenable<::test_protocols::Transitional::Request> |
| Request( |
| ::fidl::Request<::test_protocols::Transitional::Request> request) const; |
| |
| ::fitx::result<::fidl::Error> OneWay( |
| ::fidl::Request<::test_protocols::Transitional::OneWay> request) const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::Transitional> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| virtual void Event(::fidl::Event<::test_protocols::Transitional::Event>&) = 0; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::Transitional> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::Transitional>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| void Event(::fidl::Event<::test_protocols::Transitional::Event>&) override {} |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher<::test_protocols::Transitional> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::Transitional>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::Transitional>* event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender<::test_protocols::Transitional> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| ::fitx::result<::fidl::Error> Event( |
| ::test_protocols::TransitionalEventRequest payload); |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender<::test_protocols::Transitional> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::Transitional>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| ::fitx::result<::fidl::Error> Event( |
| ::test_protocols::TransitionalEventRequest payload); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::Transitional::Request> final |
| : public ::test_protocols::TransitionalRequestRequest { |
| public: |
| using ::test_protocols::TransitionalRequestRequest:: |
| TransitionalRequestRequest; |
| Request(::test_protocols::TransitionalRequestRequest v) |
| : ::test_protocols::TransitionalRequestRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::Transitional::Request>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::TransitionalRequestRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::Transitional::OneWay> final |
| : public ::test_protocols::TransitionalOneWayRequest { |
| public: |
| using ::test_protocols::TransitionalOneWayRequest::TransitionalOneWayRequest; |
| Request(::test_protocols::TransitionalOneWayRequest v) |
| : ::test_protocols::TransitionalOneWayRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::Transitional::OneWay>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::TransitionalOneWayRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::Transitional::Request> : public ::fidl::CompleterBase { |
| public: |
| void Reply( |
| ::fidl::Response<::test_protocols::Transitional::Request>&& response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::Server<::test_protocols::Transitional> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::Transitional; |
| |
| using RequestRequest = |
| ::fidl::Request<::test_protocols::Transitional::Request>; |
| using RequestCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::Transitional::Request>; |
| |
| virtual void Request(RequestRequest& request, |
| RequestCompleter::Sync& completer) { |
| completer.Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| |
| using OneWayRequest = ::fidl::Request<::test_protocols::Transitional::OneWay>; |
| using OneWayCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::Transitional::OneWay>; |
| |
| virtual void OneWay(OneWayRequest& request, |
| OneWayCompleter::Sync& completer) { |
| completer.Close(ZX_ERR_NOT_SUPPORTED); |
| } |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher<::test_protocols::Transitional> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch(::fidl::Server<::test_protocols::Transitional>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_MethodWithUnionUnionMethodRequestTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class ::fidl::internal::NaturalClientImpl<::test_protocols::MethodWithUnion> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fitx::result<::fidl::Error> UnionMethod( |
| ::fidl::Request<::test_protocols::MethodWithUnion::UnionMethod> request) |
| const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::MethodWithUnion> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::MethodWithUnion>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher< |
| ::test_protocols::MethodWithUnion> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::MethodWithUnion>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::MethodWithUnion>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender< |
| ::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::MethodWithUnion>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::MethodWithUnion::UnionMethod> final |
| : public ::test_protocols::MethodWithUnionUnionMethodRequest { |
| public: |
| using ::test_protocols::MethodWithUnionUnionMethodRequest:: |
| MethodWithUnionUnionMethodRequest; |
| Request(::test_protocols::MethodWithUnionUnionMethodRequest v) |
| : ::test_protocols::MethodWithUnionUnionMethodRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::MethodWithUnion::UnionMethod>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::MethodWithUnionUnionMethodRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::Server<::test_protocols::MethodWithUnion> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::MethodWithUnion; |
| |
| using UnionMethodRequest = |
| ::fidl::Request<::test_protocols::MethodWithUnion::UnionMethod>; |
| using UnionMethodCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::MethodWithUnion::UnionMethod>; |
| |
| virtual void UnionMethod(UnionMethodRequest& request, |
| UnionMethodCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::MethodWithUnion> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch(::fidl::Server<::test_protocols::MethodWithUnion>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithProtocolEnds::ClientEnds> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithProtocolEnds::ClientEnds>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithProtocolEnds::ClientEnds>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithProtocolEnds::ServerEnds> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithProtocolEnds::ServerEnds>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithProtocolEnds::ServerEnds>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsClientEndsRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsClientEndsTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsServerEndsRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsServerEndsTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsStructContainingEndsRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithProtocolEndsStructContainingEndsTopResponseTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| |
| template <> |
| class ::fidl::Response<::test_protocols::WithProtocolEnds::ClientEnds> final |
| : public ::test_protocols::WithProtocolEndsClientEndsTopResponse { |
| public: |
| using ::test_protocols::WithProtocolEndsClientEndsTopResponse:: |
| WithProtocolEndsClientEndsTopResponse; |
| Response(::test_protocols::WithProtocolEndsClientEndsTopResponse v) |
| : WithProtocolEndsClientEndsTopResponse(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::WithProtocolEnds::ClientEnds>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithProtocolEndsClientEndsTopResponse; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| template <> |
| class ::fidl::Result<::test_protocols::WithProtocolEnds::ClientEnds> final |
| : public ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::WithProtocolEndsClientEndsTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::WithProtocolEndsClientEndsTopResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response<::test_protocols::WithProtocolEnds::ServerEnds> final |
| : public ::test_protocols::WithProtocolEndsServerEndsTopResponse { |
| public: |
| using ::test_protocols::WithProtocolEndsServerEndsTopResponse:: |
| WithProtocolEndsServerEndsTopResponse; |
| Response(::test_protocols::WithProtocolEndsServerEndsTopResponse v) |
| : WithProtocolEndsServerEndsTopResponse(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::WithProtocolEnds::ServerEnds>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithProtocolEndsServerEndsTopResponse; |
| }; |
| template <> |
| class ::fidl::Result<::test_protocols::WithProtocolEnds::ServerEnds> final |
| : public ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::WithProtocolEndsServerEndsTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::WithProtocolEndsServerEndsTopResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final |
| : public ::test_protocols::WithProtocolEndsStructContainingEndsTopResponse { |
| public: |
| using ::test_protocols::WithProtocolEndsStructContainingEndsTopResponse:: |
| WithProtocolEndsStructContainingEndsTopResponse; |
| Response(::test_protocols::WithProtocolEndsStructContainingEndsTopResponse v) |
| : WithProtocolEndsStructContainingEndsTopResponse(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = |
| ::test_protocols::WithProtocolEndsStructContainingEndsTopResponse; |
| }; |
| template <> |
| class ::fidl::Result<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final |
| : public ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::WithProtocolEndsStructContainingEndsTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::WithProtocolEndsStructContainingEndsTopResponse>:: |
| result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalClientImpl<::test_protocols::WithProtocolEnds> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| ClientEnds(::fidl::Request<::test_protocols::WithProtocolEnds::ClientEnds> |
| request) const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| ServerEnds(::fidl::Request<::test_protocols::WithProtocolEnds::ServerEnds> |
| request) const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| StructContainingEnds( |
| ::fidl::Request<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| request) const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::WithProtocolEnds> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::WithProtocolEnds>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher< |
| ::test_protocols::WithProtocolEnds> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::WithProtocolEnds>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::WithProtocolEnds>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender< |
| ::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::WithProtocolEnds>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::WithProtocolEnds::ClientEnds> final |
| : public ::test_protocols::WithProtocolEndsClientEndsRequest { |
| public: |
| using ::test_protocols::WithProtocolEndsClientEndsRequest:: |
| WithProtocolEndsClientEndsRequest; |
| Request(::test_protocols::WithProtocolEndsClientEndsRequest v) |
| : ::test_protocols::WithProtocolEndsClientEndsRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::WithProtocolEnds::ClientEnds>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithProtocolEndsClientEndsRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::WithProtocolEnds::ServerEnds> final |
| : public ::test_protocols::WithProtocolEndsServerEndsRequest { |
| public: |
| using ::test_protocols::WithProtocolEndsServerEndsRequest:: |
| WithProtocolEndsServerEndsRequest; |
| Request(::test_protocols::WithProtocolEndsServerEndsRequest v) |
| : ::test_protocols::WithProtocolEndsServerEndsRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::WithProtocolEnds::ServerEnds>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithProtocolEndsServerEndsRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::WithProtocolEnds::StructContainingEnds> |
| final |
| : public ::test_protocols::WithProtocolEndsStructContainingEndsRequest { |
| public: |
| using ::test_protocols::WithProtocolEndsStructContainingEndsRequest:: |
| WithProtocolEndsStructContainingEndsRequest; |
| Request(::test_protocols::WithProtocolEndsStructContainingEndsRequest v) |
| : ::test_protocols::WithProtocolEndsStructContainingEndsRequest( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::WithProtocolEnds::StructContainingEnds>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithProtocolEndsStructContainingEndsRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithProtocolEnds::ClientEnds> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(::fidl::Response<::test_protocols::WithProtocolEnds::ClientEnds>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithProtocolEnds::ServerEnds> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(::fidl::Response<::test_protocols::WithProtocolEnds::ServerEnds>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply( |
| ::fidl::Response< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>&& response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::Server<::test_protocols::WithProtocolEnds> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::WithProtocolEnds; |
| |
| using ClientEndsRequest = |
| ::fidl::Request<::test_protocols::WithProtocolEnds::ClientEnds>; |
| using ClientEndsCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithProtocolEnds::ClientEnds>; |
| |
| virtual void ClientEnds(ClientEndsRequest& request, |
| ClientEndsCompleter::Sync& completer) = 0; |
| |
| using ServerEndsRequest = |
| ::fidl::Request<::test_protocols::WithProtocolEnds::ServerEnds>; |
| using ServerEndsCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithProtocolEnds::ServerEnds>; |
| |
| virtual void ServerEnds(ServerEndsRequest& request, |
| ServerEndsCompleter::Sync& completer) = 0; |
| |
| using StructContainingEndsRequest = |
| ::fidl::Request<::test_protocols::WithProtocolEnds::StructContainingEnds>; |
| using StructContainingEndsCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithProtocolEnds::StructContainingEnds>; |
| |
| virtual void StructContainingEnds( |
| StructContainingEndsRequest& request, |
| StructContainingEndsCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::WithProtocolEnds> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch(::fidl::Server<::test_protocols::WithProtocolEnds>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ManyParametersFifteenRequestTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| template <> |
| class ::fidl::internal::NaturalClientImpl<::test_protocols::ManyParameters> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fitx::result<::fidl::Error> Fifteen( |
| ::fidl::Request<::test_protocols::ManyParameters::Fifteen> request) const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::ManyParameters> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::ManyParameters> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::ManyParameters>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher<::test_protocols::ManyParameters> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::ManyParameters>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::ManyParameters>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender<::test_protocols::ManyParameters> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender<::test_protocols::ManyParameters> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::ManyParameters>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::ManyParameters::Fifteen> final |
| : public ::test_protocols::ManyParametersFifteenRequest { |
| public: |
| using ::test_protocols::ManyParametersFifteenRequest:: |
| ManyParametersFifteenRequest; |
| Request(::test_protocols::ManyParametersFifteenRequest v) |
| : ::test_protocols::ManyParametersFifteenRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::ManyParameters::Fifteen>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ManyParametersFifteenRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::Server<::test_protocols::ManyParameters> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::ManyParameters; |
| |
| using FifteenRequest = |
| ::fidl::Request<::test_protocols::ManyParameters::Fifteen>; |
| using FifteenCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::ManyParameters::Fifteen>; |
| |
| virtual void Fifteen(FifteenRequest& request, |
| FifteenCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::ManyParameters> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch(::fidl::Server<::test_protocols::ManyParameters>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::HandleRightsProtocol::ResponseMethod>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolNoResponseMethodRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolResponseMethodRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolResponseMethodTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_HandleRightsProtocolAnEventRequestTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| |
| template <> |
| class ::fidl::Event<::test_protocols::HandleRightsProtocol::AnEvent> final |
| : public ::test_protocols::HandleRightsProtocolAnEventRequest { |
| public: |
| using ::test_protocols::HandleRightsProtocolAnEventRequest:: |
| HandleRightsProtocolAnEventRequest; |
| Event(::test_protocols::HandleRightsProtocolAnEventRequest v) |
| : HandleRightsProtocolAnEventRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Event<::test_protocols::HandleRightsProtocol::AnEvent>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::HandleRightsProtocolAnEventRequest; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| |
| template <> |
| class ::fidl::Response<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final |
| : public ::test_protocols::HandleRightsProtocolResponseMethodTopResponse { |
| public: |
| using ::test_protocols::HandleRightsProtocolResponseMethodTopResponse:: |
| HandleRightsProtocolResponseMethodTopResponse; |
| Response(::test_protocols::HandleRightsProtocolResponseMethodTopResponse v) |
| : HandleRightsProtocolResponseMethodTopResponse(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = |
| ::test_protocols::HandleRightsProtocolResponseMethodTopResponse; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| template <> |
| class ::fidl::Result<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final |
| : public ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::HandleRightsProtocolResponseMethodTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::HandleRightsProtocolResponseMethodTopResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalClientImpl< |
| ::test_protocols::HandleRightsProtocol> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| ResponseMethod( |
| ::fidl::Request<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| request) const; |
| |
| ::fitx::result<::fidl::Error> NoResponseMethod( |
| ::fidl::Request<::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| request) const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::HandleRightsProtocol> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| virtual void AnEvent( |
| ::fidl::Event<::test_protocols::HandleRightsProtocol::AnEvent>&) = 0; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::HandleRightsProtocol>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| void AnEvent(::fidl::Event<::test_protocols::HandleRightsProtocol::AnEvent>&) |
| override {} |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher< |
| ::test_protocols::HandleRightsProtocol> |
| final |
| : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::HandleRightsProtocol>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::HandleRightsProtocol>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender< |
| ::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| ::fitx::result<::fidl::Error> AnEvent( |
| ::test_protocols::HandleRightsProtocolAnEventRequest payload); |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender< |
| ::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::HandleRightsProtocol>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| ::fitx::result<::fidl::Error> AnEvent( |
| ::test_protocols::HandleRightsProtocolAnEventRequest payload); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::HandleRightsProtocol::NoResponseMethod> |
| final |
| : public ::test_protocols::HandleRightsProtocolNoResponseMethodRequest { |
| public: |
| using ::test_protocols::HandleRightsProtocolNoResponseMethodRequest:: |
| HandleRightsProtocolNoResponseMethodRequest; |
| Request(::test_protocols::HandleRightsProtocolNoResponseMethodRequest v) |
| : ::test_protocols::HandleRightsProtocolNoResponseMethodRequest( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::HandleRightsProtocol::NoResponseMethod>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::HandleRightsProtocolNoResponseMethodRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::HandleRightsProtocol::ResponseMethod> |
| final : public ::test_protocols::HandleRightsProtocolResponseMethodRequest { |
| public: |
| using ::test_protocols::HandleRightsProtocolResponseMethodRequest:: |
| HandleRightsProtocolResponseMethodRequest; |
| Request(::test_protocols::HandleRightsProtocolResponseMethodRequest v) |
| : ::test_protocols::HandleRightsProtocolResponseMethodRequest( |
| std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::HandleRightsProtocol::ResponseMethod>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::HandleRightsProtocolResponseMethodRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply( |
| ::fidl::Response<::test_protocols::HandleRightsProtocol::ResponseMethod>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::Server<::test_protocols::HandleRightsProtocol> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::HandleRightsProtocol; |
| |
| using NoResponseMethodRequest = |
| ::fidl::Request<::test_protocols::HandleRightsProtocol::NoResponseMethod>; |
| using NoResponseMethodCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::HandleRightsProtocol::NoResponseMethod>; |
| |
| virtual void NoResponseMethod(NoResponseMethodRequest& request, |
| NoResponseMethodCompleter::Sync& completer) = 0; |
| |
| using ResponseMethodRequest = |
| ::fidl::Request<::test_protocols::HandleRightsProtocol::ResponseMethod>; |
| using ResponseMethodCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::HandleRightsProtocol::ResponseMethod>; |
| |
| virtual void ResponseMethod(ResponseMethodRequest& request, |
| ResponseMethodCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::HandleRightsProtocol> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch( |
| ::fidl::Server<::test_protocols::HandleRightsProtocol>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithErrorSyntax::ResponseAsStruct>&)>; |
| |
| static constexpr bool HasApplicationError = true; |
| |
| static constexpr bool IsEmptyStructPayload = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>&)>; |
| |
| static constexpr bool HasApplicationError = true; |
| |
| static constexpr bool IsEmptyStructPayload = true; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithErrorSyntax::ErrorAsEnum>&)>; |
| |
| static constexpr bool HasApplicationError = true; |
| |
| static constexpr bool IsEmptyStructPayload = true; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::WithErrorSyntax::HandleInResult> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::HandleInResult>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::WithErrorSyntax::HandleInResult>&)>; |
| |
| static constexpr bool HasApplicationError = true; |
| |
| static constexpr bool IsEmptyStructPayload = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxResponseAsStructTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxErrorAsPrimitiveTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxErrorAsEnumTopResponseTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_WithErrorSyntaxHandleInResultTopResponseTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| |
| template <> |
| class ::fidl::Response<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final |
| : public ::fitx::result< |
| uint32_t, ::test_protocols::WithErrorSyntaxResponseAsStructResponse> { |
| public: |
| using ::fitx::result< |
| uint32_t, |
| ::test_protocols::WithErrorSyntaxResponseAsStructResponse>::result; |
| Response(::fitx::result< |
| uint32_t, ::test_protocols::WithErrorSyntaxResponseAsStructResponse> |
| v) |
| : result(std::move(v)) {} |
| Response() = delete; |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithErrorSyntaxResponseAsStructTopResponse; |
| }; |
| template <> |
| class ::fidl::internal::NaturalMessageConverter< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ResponseAsStruct>> { |
| using DomainObject = |
| ::test_protocols::WithErrorSyntaxResponseAsStructTopResponse; |
| |
| public: |
| static ::fidl::Response<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| FromDomainObject(DomainObject o) { |
| if (o.result().err().has_value()) { |
| return ::fitx::error(std::move(o.result().err().value())); |
| } else { |
| ZX_DEBUG_ASSERT(o.result().response().has_value()); |
| return ::fitx::ok(std::move(o.result().response().value())); |
| } |
| } |
| |
| static DomainObject IntoDomainObject( |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ResponseAsStruct>&& |
| m) { |
| if (m.is_error()) { |
| return DomainObject{ |
| {.result = |
| ::test_protocols::WithErrorSyntaxResponseAsStructResult::WithErr( |
| m.error_value())}}; |
| } else { |
| return DomainObject{ |
| {.result = ::test_protocols::WithErrorSyntaxResponseAsStructResult:: |
| WithResponse(std::move(m.value()))}}; |
| } |
| } |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| template <> |
| class ::fidl::Result<::test_protocols::WithErrorSyntax::ResponseAsStruct> final |
| : public ::fitx::result< |
| ::fidl::AnyErrorIn< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| ::test_protocols::WithErrorSyntaxResponseAsStructResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::AnyErrorIn<::test_protocols::WithErrorSyntax::ResponseAsStruct>, |
| ::test_protocols::WithErrorSyntaxResponseAsStructResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final : public ::fitx::result<uint32_t> { |
| public: |
| using ::fitx::result<uint32_t>::result; |
| Response(::fitx::result<uint32_t> v) : result(std::move(v)) {} |
| Response() = delete; |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithErrorSyntaxErrorAsPrimitiveTopResponse; |
| }; |
| template <> |
| class ::fidl::internal::NaturalMessageConverter< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> { |
| using DomainObject = |
| ::test_protocols::WithErrorSyntaxErrorAsPrimitiveTopResponse; |
| |
| public: |
| static ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| FromDomainObject(DomainObject o) { |
| if (o.result().err().has_value()) { |
| return ::fitx::error(std::move(o.result().err().value())); |
| } else { |
| ZX_DEBUG_ASSERT(o.result().response().has_value()); |
| return ::fitx::ok(); |
| } |
| } |
| |
| static DomainObject IntoDomainObject( |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>&& |
| m) { |
| if (m.is_error()) { |
| return DomainObject{ |
| {.result = |
| ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult::WithErr( |
| m.error_value())}}; |
| } else { |
| return DomainObject{ |
| {.result = ::test_protocols::WithErrorSyntaxErrorAsPrimitiveResult:: |
| WithResponse({})}}; |
| } |
| } |
| }; |
| template <> |
| class ::fidl::Result<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> final |
| : public ::fitx::result<::fidl::AnyErrorIn< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> { |
| public: |
| using ::fitx::result<::fidl::AnyErrorIn< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsEnum> final |
| : public ::fitx::result<::test_protocols::ErrorEnum> { |
| public: |
| using ::fitx::result<::test_protocols::ErrorEnum>::result; |
| Response(::fitx::result<::test_protocols::ErrorEnum> v) |
| : result(std::move(v)) {} |
| Response() = delete; |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsEnum>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithErrorSyntaxErrorAsEnumTopResponse; |
| }; |
| template <> |
| class ::fidl::internal::NaturalMessageConverter< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsEnum>> { |
| using DomainObject = ::test_protocols::WithErrorSyntaxErrorAsEnumTopResponse; |
| |
| public: |
| static ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| FromDomainObject(DomainObject o) { |
| if (o.result().err().has_value()) { |
| return ::fitx::error(std::move(o.result().err().value())); |
| } else { |
| ZX_DEBUG_ASSERT(o.result().response().has_value()); |
| return ::fitx::ok(); |
| } |
| } |
| |
| static DomainObject IntoDomainObject( |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsEnum>&& m) { |
| if (m.is_error()) { |
| return DomainObject{ |
| {.result = |
| ::test_protocols::WithErrorSyntaxErrorAsEnumResult::WithErr( |
| m.error_value())}}; |
| } else { |
| return DomainObject{ |
| {.result = |
| ::test_protocols::WithErrorSyntaxErrorAsEnumResult::WithResponse( |
| {})}}; |
| } |
| } |
| }; |
| template <> |
| class ::fidl::Result<::test_protocols::WithErrorSyntax::ErrorAsEnum> final |
| : public ::fitx::result< |
| ::fidl::AnyErrorIn<::test_protocols::WithErrorSyntax::ErrorAsEnum>> { |
| public: |
| using ::fitx::result<::fidl::AnyErrorIn< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response<::test_protocols::WithErrorSyntax::HandleInResult> final |
| : public ::fitx::result< |
| uint32_t, ::test_protocols::WithErrorSyntaxHandleInResultResponse> { |
| public: |
| using ::fitx::result< |
| uint32_t, |
| ::test_protocols::WithErrorSyntaxHandleInResultResponse>::result; |
| Response(::fitx::result< |
| uint32_t, ::test_protocols::WithErrorSyntaxHandleInResultResponse> |
| v) |
| : result(std::move(v)) {} |
| Response() = delete; |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::HandleInResult>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::WithErrorSyntaxHandleInResultTopResponse; |
| }; |
| template <> |
| class ::fidl::internal::NaturalMessageConverter< |
| ::fidl::Response<::test_protocols::WithErrorSyntax::HandleInResult>> { |
| using DomainObject = |
| ::test_protocols::WithErrorSyntaxHandleInResultTopResponse; |
| |
| public: |
| static ::fidl::Response<::test_protocols::WithErrorSyntax::HandleInResult> |
| FromDomainObject(DomainObject o) { |
| if (o.result().err().has_value()) { |
| return ::fitx::error(std::move(o.result().err().value())); |
| } else { |
| ZX_DEBUG_ASSERT(o.result().response().has_value()); |
| return ::fitx::ok(std::move(o.result().response().value())); |
| } |
| } |
| |
| static DomainObject IntoDomainObject( |
| ::fidl::Response<::test_protocols::WithErrorSyntax::HandleInResult>&& m) { |
| if (m.is_error()) { |
| return DomainObject{ |
| {.result = |
| ::test_protocols::WithErrorSyntaxHandleInResultResult::WithErr( |
| m.error_value())}}; |
| } else { |
| return DomainObject{ |
| {.result = ::test_protocols::WithErrorSyntaxHandleInResultResult:: |
| WithResponse(std::move(m.value()))}}; |
| } |
| } |
| }; |
| template <> |
| class ::fidl::Result<::test_protocols::WithErrorSyntax::HandleInResult> final |
| : public ::fitx::result< |
| ::fidl::AnyErrorIn<::test_protocols::WithErrorSyntax::HandleInResult>, |
| ::test_protocols::WithErrorSyntaxHandleInResultResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::AnyErrorIn<::test_protocols::WithErrorSyntax::HandleInResult>, |
| ::test_protocols::WithErrorSyntaxHandleInResultResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalClientImpl<::test_protocols::WithErrorSyntax> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| ResponseAsStruct() const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| ErrorAsPrimitive() const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| ErrorAsEnum() const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| HandleInResult() const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::WithErrorSyntax> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::WithErrorSyntax>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher< |
| ::test_protocols::WithErrorSyntax> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::WithErrorSyntax>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::WithErrorSyntax>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender< |
| ::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::WithErrorSyntax>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::WithErrorSyntax::ResponseAsStruct>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::WithErrorSyntax::ErrorAsEnum> final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::WithErrorSyntax::ErrorAsEnum>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::WithErrorSyntax::HandleInResult> final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::WithErrorSyntax::HandleInResult>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply( |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ResponseAsStruct>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply( |
| ::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(::fidl::Response<::test_protocols::WithErrorSyntax::ErrorAsEnum>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::WithErrorSyntax::HandleInResult> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply( |
| ::fidl::Response<::test_protocols::WithErrorSyntax::HandleInResult>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::Server<::test_protocols::WithErrorSyntax> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::WithErrorSyntax; |
| |
| using ResponseAsStructRequest = |
| ::fidl::Request<::test_protocols::WithErrorSyntax::ResponseAsStruct>; |
| using ResponseAsStructCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithErrorSyntax::ResponseAsStruct>; |
| |
| virtual void ResponseAsStruct(ResponseAsStructRequest& request, |
| ResponseAsStructCompleter::Sync& completer) = 0; |
| |
| using ErrorAsPrimitiveRequest = |
| ::fidl::Request<::test_protocols::WithErrorSyntax::ErrorAsPrimitive>; |
| using ErrorAsPrimitiveCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithErrorSyntax::ErrorAsPrimitive>; |
| |
| virtual void ErrorAsPrimitive(ErrorAsPrimitiveRequest& request, |
| ErrorAsPrimitiveCompleter::Sync& completer) = 0; |
| |
| using ErrorAsEnumRequest = |
| ::fidl::Request<::test_protocols::WithErrorSyntax::ErrorAsEnum>; |
| using ErrorAsEnumCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithErrorSyntax::ErrorAsEnum>; |
| |
| virtual void ErrorAsEnum(ErrorAsEnumRequest& request, |
| ErrorAsEnumCompleter::Sync& completer) = 0; |
| |
| using HandleInResultRequest = |
| ::fidl::Request<::test_protocols::WithErrorSyntax::HandleInResult>; |
| using HandleInResultCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::WithErrorSyntax::HandleInResult>; |
| |
| virtual void HandleInResult(HandleInResultRequest& request, |
| HandleInResultCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::WithErrorSyntax> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch(::fidl::Server<::test_protocols::WithErrorSyntax>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalClientImpl< |
| ::test_protocols::DiscoverableProtocol> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fitx::result<::fidl::Error> Method() const; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::DiscoverableProtocol> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::DiscoverableProtocol>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher< |
| ::test_protocols::DiscoverableProtocol> |
| final |
| : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::DiscoverableProtocol>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::DiscoverableProtocol>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender< |
| ::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender< |
| ::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::DiscoverableProtocol>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::DiscoverableProtocol::Method> final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::DiscoverableProtocol::Method>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::Server<::test_protocols::DiscoverableProtocol> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::DiscoverableProtocol; |
| |
| using MethodRequest = |
| ::fidl::Request<::test_protocols::DiscoverableProtocol::Method>; |
| using MethodCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::DiscoverableProtocol::Method>; |
| |
| virtual void Method(MethodRequest& request, |
| MethodCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::DiscoverableProtocol> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch( |
| ::fidl::Server<::test_protocols::DiscoverableProtocol>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::ChannelProtocol::MethodB> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::ChannelProtocol::MethodB>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::ChannelProtocol::MethodB>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::ChannelProtocol::TakeHandle> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::ChannelProtocol::TakeHandle>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::ChannelProtocol::TakeHandle>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = true; |
| }; |
| |
| template <> |
| struct ::fidl::internal::NaturalMethodTypes< |
| ::test_protocols::ChannelProtocol::MutateSocket> { |
| using Completer = fidl::Completer<::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::ChannelProtocol::MutateSocket>>; |
| |
| using ResultCallback = ::fit::callback<void( |
| ::fidl::Result<::test_protocols::ChannelProtocol::MutateSocket>&)>; |
| |
| static constexpr bool HasApplicationError = false; |
| |
| static constexpr bool IsAbsentBody = false; |
| }; |
| namespace test_protocols { |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMethodARequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolEventARequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMethodBRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMethodBTopResponseTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolTakeHandleRequestTable; |
| |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMutateSocketRequestTable; |
| __LOCAL extern "C" const fidl_type_t |
| test_protocols_ChannelProtocolMutateSocketTopResponseTable; |
| |
| #ifdef __Fuchsia__ |
| } // namespace test_protocols |
| |
| template <> |
| class ::fidl::Event<::test_protocols::ChannelProtocol::EventA> final |
| : public ::test_protocols::ChannelProtocolEventARequest { |
| public: |
| using ::test_protocols::ChannelProtocolEventARequest:: |
| ChannelProtocolEventARequest; |
| Event(::test_protocols::ChannelProtocolEventARequest v) |
| : ChannelProtocolEventARequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Event<::test_protocols::ChannelProtocol::EventA>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ChannelProtocolEventARequest; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| |
| template <> |
| class ::fidl::Response<::test_protocols::ChannelProtocol::MethodB> final |
| : public ::test_protocols::ChannelProtocolMethodBTopResponse { |
| public: |
| using ::test_protocols::ChannelProtocolMethodBTopResponse:: |
| ChannelProtocolMethodBTopResponse; |
| Response(::test_protocols::ChannelProtocolMethodBTopResponse v) |
| : ChannelProtocolMethodBTopResponse(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::ChannelProtocol::MethodB>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ChannelProtocolMethodBTopResponse; |
| }; |
| namespace test_protocols {} // namespace test_protocols |
| template <> |
| class ::fidl::Result<::test_protocols::ChannelProtocol::MethodB> final |
| : public ::fitx::result< |
| ::fidl::Error, ::test_protocols::ChannelProtocolMethodBTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::ChannelProtocolMethodBTopResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response<::test_protocols::ChannelProtocol::TakeHandle> final { |
| public: |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::ChannelProtocol::TakeHandle>> |
| final { |
| public: |
| static constexpr bool kHasPayload = false; |
| }; |
| template <> |
| class ::fidl::Result<::test_protocols::ChannelProtocol::TakeHandle> final |
| : public ::fitx::result<::fidl::Error> { |
| public: |
| using ::fitx::result<::fidl::Error>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::Response<::test_protocols::ChannelProtocol::MutateSocket> final |
| : public ::test_protocols::ChannelProtocolMutateSocketTopResponse { |
| public: |
| using ::test_protocols::ChannelProtocolMutateSocketTopResponse:: |
| ChannelProtocolMutateSocketTopResponse; |
| Response(::test_protocols::ChannelProtocolMutateSocketTopResponse v) |
| : ChannelProtocolMutateSocketTopResponse(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Response<::test_protocols::ChannelProtocol::MutateSocket>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ChannelProtocolMutateSocketTopResponse; |
| }; |
| template <> |
| class ::fidl::Result<::test_protocols::ChannelProtocol::MutateSocket> final |
| : public ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::ChannelProtocolMutateSocketTopResponse> { |
| public: |
| using ::fitx::result< |
| ::fidl::Error, |
| ::test_protocols::ChannelProtocolMutateSocketTopResponse>::result; |
| |
| protected: |
| Result() = default; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalClientImpl<::test_protocols::ChannelProtocol> |
| final : public ::fidl::internal::NaturalClientBase { |
| public: |
| using NaturalClientBase::NaturalClientBase; |
| ::fidl::internal::NaturalThenable<::test_protocols::ChannelProtocol::MethodB> |
| MethodB(::fidl::Request<::test_protocols::ChannelProtocol::MethodB> request) |
| const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| TakeHandle(::fidl::Request<::test_protocols::ChannelProtocol::TakeHandle> |
| request) const; |
| |
| ::fidl::internal::NaturalThenable< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| MutateSocket(::fidl::Request<::test_protocols::ChannelProtocol::MutateSocket> |
| request) const; |
| |
| ::fitx::result<::fidl::Error> MethodA( |
| ::fidl::Request<::test_protocols::ChannelProtocol::MethodA> request) |
| const; |
| }; |
| namespace test_protocols { |
| #endif // __Fuchsia__ |
| |
| } // namespace test_protocols |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::ChannelProtocol> { |
| public: |
| NaturalEventHandlerInterface() = default; |
| virtual ~NaturalEventHandlerInterface() = default; |
| virtual void EventA( |
| ::fidl::Event<::test_protocols::ChannelProtocol::EventA>&) = 0; |
| }; |
| |
| template <> |
| class ::fidl::AsyncEventHandler<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::NaturalEventHandlerInterface< |
| ::test_protocols::ChannelProtocol>, |
| public ::fidl::internal::AsyncEventHandler { |
| public: |
| AsyncEventHandler() = default; |
| void EventA( |
| ::fidl::Event<::test_protocols::ChannelProtocol::EventA>&) override {} |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventDispatcher< |
| ::test_protocols::ChannelProtocol> |
| final : public ::fidl::internal::IncomingEventDispatcher< |
| ::fidl::AsyncEventHandler<::test_protocols::ChannelProtocol>> { |
| public: |
| explicit NaturalEventDispatcher( |
| ::fidl::AsyncEventHandler<::test_protocols::ChannelProtocol>* |
| event_handler) |
| : IncomingEventDispatcher(event_handler) {} |
| |
| private: |
| std::optional<::fidl::UnbindInfo> DispatchEvent( |
| ::fidl::IncomingMessage& msg, |
| internal::IncomingTransportContext transport_context) override; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| template <> |
| class ::fidl::internal::NaturalWeakEventSender< |
| ::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::WeakEventSenderBase { |
| public: |
| using WeakEventSenderBase::WeakEventSenderBase; |
| |
| ::fitx::result<::fidl::Error> EventA( |
| ::test_protocols::ChannelProtocolEventARequest payload); |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalEventSender<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::SyncEndpointManagedVeneer< |
| ::fidl::internal::NaturalEventSender< |
| ::test_protocols::ChannelProtocol>> { |
| public: |
| using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer; |
| |
| ::fitx::result<::fidl::Error> EventA( |
| ::test_protocols::ChannelProtocolEventARequest payload); |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::ChannelProtocol::MethodA> final |
| : public ::test_protocols::ChannelProtocolMethodARequest { |
| public: |
| using ::test_protocols::ChannelProtocolMethodARequest:: |
| ChannelProtocolMethodARequest; |
| Request(::test_protocols::ChannelProtocolMethodARequest v) |
| : ::test_protocols::ChannelProtocolMethodARequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::ChannelProtocol::MethodA>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ChannelProtocolMethodARequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::ChannelProtocol::MethodB> final |
| : public ::test_protocols::ChannelProtocolMethodBRequest { |
| public: |
| using ::test_protocols::ChannelProtocolMethodBRequest:: |
| ChannelProtocolMethodBRequest; |
| Request(::test_protocols::ChannelProtocolMethodBRequest v) |
| : ::test_protocols::ChannelProtocolMethodBRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::ChannelProtocol::MethodB>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ChannelProtocolMethodBRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::ChannelProtocol::TakeHandle> final |
| : public ::test_protocols::ChannelProtocolTakeHandleRequest { |
| public: |
| using ::test_protocols::ChannelProtocolTakeHandleRequest:: |
| ChannelProtocolTakeHandleRequest; |
| Request(::test_protocols::ChannelProtocolTakeHandleRequest v) |
| : ::test_protocols::ChannelProtocolTakeHandleRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::ChannelProtocol::TakeHandle>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ChannelProtocolTakeHandleRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| class ::fidl::Request<::test_protocols::ChannelProtocol::MutateSocket> final |
| : public ::test_protocols::ChannelProtocolMutateSocketRequest { |
| public: |
| using ::test_protocols::ChannelProtocolMutateSocketRequest:: |
| ChannelProtocolMutateSocketRequest; |
| Request(::test_protocols::ChannelProtocolMutateSocketRequest v) |
| : ::test_protocols::ChannelProtocolMutateSocketRequest(std::move(v)) {} |
| }; |
| |
| template <> |
| struct ::fidl::internal::MessageTraits< |
| ::fidl::Request<::test_protocols::ChannelProtocol::MutateSocket>> |
| final { |
| public: |
| static constexpr bool kHasPayload = true; |
| using Payload = ::test_protocols::ChannelProtocolMutateSocketRequest; |
| }; |
| #endif // __Fuchsia__ |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::ChannelProtocol::MethodB> : public ::fidl::CompleterBase { |
| public: |
| void Reply( |
| ::fidl::Response<::test_protocols::ChannelProtocol::MethodB>&& response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::ChannelProtocol::TakeHandle> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::internal::NaturalCompleterBase< |
| ::test_protocols::ChannelProtocol::MutateSocket> |
| : public ::fidl::CompleterBase { |
| public: |
| void Reply(::fidl::Response<::test_protocols::ChannelProtocol::MutateSocket>&& |
| response); |
| |
| protected: |
| using ::fidl::CompleterBase::CompleterBase; |
| }; |
| |
| template <> |
| class ::fidl::Server<::test_protocols::ChannelProtocol> |
| : public ::fidl::internal::IncomingMessageDispatcher { |
| public: |
| Server() = default; |
| virtual ~Server() = default; |
| |
| // The FIDL protocol type that is implemented by this server. |
| using _EnclosingProtocol = ::test_protocols::ChannelProtocol; |
| |
| using MethodARequest = |
| ::fidl::Request<::test_protocols::ChannelProtocol::MethodA>; |
| using MethodACompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::ChannelProtocol::MethodA>; |
| |
| virtual void MethodA(MethodARequest& request, |
| MethodACompleter::Sync& completer) = 0; |
| |
| using MethodBRequest = |
| ::fidl::Request<::test_protocols::ChannelProtocol::MethodB>; |
| using MethodBCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::ChannelProtocol::MethodB>; |
| |
| virtual void MethodB(MethodBRequest& request, |
| MethodBCompleter::Sync& completer) = 0; |
| |
| using TakeHandleRequest = |
| ::fidl::Request<::test_protocols::ChannelProtocol::TakeHandle>; |
| using TakeHandleCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::ChannelProtocol::TakeHandle>; |
| |
| virtual void TakeHandle(TakeHandleRequest& request, |
| TakeHandleCompleter::Sync& completer) = 0; |
| |
| using MutateSocketRequest = |
| ::fidl::Request<::test_protocols::ChannelProtocol::MutateSocket>; |
| using MutateSocketCompleter = ::fidl::internal::NaturalCompleter< |
| ::test_protocols::ChannelProtocol::MutateSocket>; |
| |
| virtual void MutateSocket(MutateSocketRequest& request, |
| MutateSocketCompleter::Sync& completer) = 0; |
| |
| private: |
| void dispatch_message( |
| ::fidl::IncomingMessage&& msg, ::fidl::Transaction* txn, |
| ::fidl::internal::IncomingTransportContext transport_context) final; |
| }; |
| |
| #ifdef __Fuchsia__ |
| |
| template <> |
| struct ::fidl::internal::NaturalServerDispatcher< |
| ::test_protocols::ChannelProtocol> |
| final { |
| NaturalServerDispatcher() = delete; |
| static void Dispatch(::fidl::Server<::test_protocols::ChannelProtocol>* impl, |
| ::fidl::IncomingMessage&& msg, |
| internal::IncomingTransportContext transport_context, |
| ::fidl::Transaction* txn); |
| |
| private: |
| static const ::fidl::internal::MethodEntry entries_[]; |
| static const ::fidl::internal::MethodEntry* entries_end_; |
| }; |
| #endif // __Fuchsia__ |
