tools/fidl/fidlgen_cpp/codegen/fragment_protocol_event_handler.tmpl

{{/*
// Copyright 2021 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
*/}}

{{- define "Protocol:EventHandler:WireMessagingHeader" }}
{{- EnsureNamespace "" }}
template<>
class {{ .WireEventHandlerInterface }} : public ::fidl::internal::BaseEventHandlerInterface
{{- if .HandlesOneWayUnknownInteractions -}}
, public {{ .UnknownEventHandler }}
{{- end }} {
public:
  {{ .WireEventHandlerInterface.Self }}() = default;
  virtual ~{{ .WireEventHandlerInterface.Self }}() = default;
  {{- range .Events -}}
    {{- .Docs }}
    virtual void {{ .Name }}({{ if .HasResponsePayload }}{{ .WireEvent }}* event{{ end }}) = 0;
  {{- end }}
};

template<>
class {{ .WireAsyncEventHandler }}
    : public {{ .WireEventHandlerInterface }}, public ::fidl::internal::AsyncEventHandler {
 public:
  {{ .WireAsyncEventHandler.Self }}() = default;
  {{- range .Events -}}
    {{- .Docs }}
    void {{ .Name }}({{ if .HasResponsePayload }}{{ .WireEvent }}* event{{ end }}) override;
  {{- end }}
};

{{ if .Transport.HasEvents }}
  template<>
  class {{ .WireSyncEventHandler }}
      : public {{ .WireEventHandlerInterface }}, public ::fidl::internal::SyncEventHandler {
   public:
    {{ .WireSyncEventHandler.Self }}() = default;

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding virtual
    // method.
    ::fidl::Status HandleOneEvent(
        {{ .UnownedClientEnd }} client_end);
  };
{{- end }}

template <>
class {{ .WireEventDispatcher }} final :
    public ::fidl::internal::IncomingEventDispatcher<{{ .WireEventHandlerInterface }}> {
 public:
  explicit {{ .WireEventDispatcher.Self }}({{ .WireEventHandlerInterface }}* event_handler);

  {{- if or .Events .HandlesOneWayUnknownInteractions }}
    ::fidl::Status DispatchEvent(
        ::fidl::IncomingHeaderAndMessage& msg,
        ::fidl::internal::MessageStorageViewBase* storage_view) override;
  {{- end }}
};
{{- end }}



{{- define "Protocol:EventHandler:WireMessagingSource" }}
{{ EnsureNamespace "" }}

{{ .WireEventDispatcher }}::{{ .WireEventDispatcher.Self }}({{ .WireEventHandlerInterface }}* event_handler)
: IncomingEventDispatcher(event_handler) {}


{{ if .Transport.HasEvents }}
  ::fidl::Status {{ .WireSyncEventHandler.NoLeading }}::HandleOneEvent(
      {{ .UnownedClientEnd }} client_end) {
      {{ .IncomingEventsStorage }} event_storage;
      {{ .WireEventDispatcher.NoLeading }} dispatcher{this};
      return HandleOneEventImpl_(client_end.channel(), event_storage.view(), dispatcher);
  }
{{- end }}

{{- if or .Events .HandlesOneWayUnknownInteractions }}
  ::fidl::Status
  {{ .WireEventDispatcher.NoLeading }}::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
    {{- range .Events }}
      case {{ .OrdinalName }}:
      {
        ::fit::result decoded = ::fidl::internal::InplaceDecodeTransactionalEvent<{{ .Marker }}>(
            std::move(msg));
        if (!decoded.is_ok()) {
          return decoded.error_value();
        }
        if (event_handler()) {
          {{- if .HasResponsePayload }}
            auto* primary = decoded.value().pointer();
          {{- end }}
          event_handler()->{{ .Name }}({{ if .HasResponsePayload }}primary{{ end }});
        }
        return ::fidl::Status::Ok();
      }
    {{- end }}
      default:
        {{- if .HandlesOneWayUnknownInteractions }}
        auto* hdr = msg.header();
        ::fidl::UnknownMethodType unknown_method_type =
            ::fidl::internal::UnknownMethodTypeFromHeader(hdr);
        bool is_flexible_interaction = ::fidl::IsFlexibleInteraction(hdr);
        auto ordinal = hdr->ordinal;
        {{- end }}
        {{- /* Close handles regardless of whether there is an unknown interaction handler. */}}
        std::move(msg).CloseHandles();
        {{- if .HandlesOneWayUnknownInteractions }}
        if (is_flexible_interaction &&
            ::fidl::internal::CanHandleEvent({{ . }}::kOpenness, unknown_method_type)) {
          if (event_handler()) {
            {{ .UnknownEventMetadata }} metadata {
              .event_ordinal = ordinal,
            };
            event_handler()->handle_unknown_event(metadata);
          }
          return ::fidl::Status::Ok();
        }
        {{- end }}
        return ::fidl::Status::UnknownOrdinal();
    }
  }
{{- end }}


{{- range .Events }}
void {{ $.WireAsyncEventHandler.NoLeading }}::{{ .Name }}({{ if .HasResponsePayload }}{{ .WireEvent }}* event{{ end }}) {}
{{- end }}


{{- end }}



{{- define "Protocol:EventHandler:NaturalMessagingHeader" }}
{{- EnsureNamespace "" }}
template<>
class {{ .NaturalEventHandlerInterface }} : public ::fidl::internal::BaseEventHandlerInterface
{{- if .HandlesOneWayUnknownInteractions -}}
, public {{ .UnknownEventHandler }}
{{- end }} {
 public:
  {{ .NaturalEventHandlerInterface.Self }}() = default;
  virtual ~{{ .NaturalEventHandlerInterface.Self }}() = default;
  {{- range .Events -}}
    {{- .Docs }}
    virtual void {{ .Name }}({{ if .HasResponsePayload }}{{ .NaturalEvent }}&{{ end }}) = 0;
  {{- end }}
};

template<>
class {{ .NaturalAsyncEventHandler }}
    : public {{ .NaturalEventHandlerInterface }}, public ::fidl::internal::AsyncEventHandler {
 public:
  {{ .NaturalAsyncEventHandler.Self }}() = default;

  {{- range .Events -}}
    {{- .Docs }}
    void {{ .Name }}({{ if .HasResponsePayload }}{{ .NaturalEvent }}&{{ end }}) override;
  {{- end }}
};

{{ if .Transport.HasEvents }}
  template<>
  class {{ .NaturalSyncEventHandler }}
      : public {{ .NaturalEventHandlerInterface }}, public ::fidl::internal::SyncEventHandler {
   public:
    {{ .NaturalSyncEventHandler.Self }}() = default;

    // Handle all possible events defined in this protocol.
    // Blocks to consume exactly one message from the channel, then call the corresponding virtual
    // method.
    ::fidl::Status HandleOneEvent(
        {{ .UnownedClientEnd }} client_end);
  };
{{- end }}

template <>
class {{ .NaturalEventDispatcher }} final :
    public ::fidl::internal::IncomingEventDispatcher<{{ .NaturalEventHandlerInterface }}> {
 public:
  explicit {{ .NaturalEventDispatcher.Self }}({{ .NaturalEventHandlerInterface }}* event_handler);

  {{- if or .Events .HandlesOneWayUnknownInteractions }}
    ::fidl::Status DispatchEvent(
        ::fidl::IncomingHeaderAndMessage& msg,
        internal::MessageStorageViewBase* storage_view) override;
  {{- end }}
};
{{- end }}



{{- define "Protocol:EventHandler:NaturalMessagingSource" }}
{{- EnsureNamespace "" }}

{{ if .Transport.HasEvents }}
  ::fidl::Status {{ .NaturalSyncEventHandler.NoLeading }}::HandleOneEvent(
      {{ .UnownedClientEnd }} client_end) {
      {{ .IncomingEventsStorage }} event_storage;
      {{ .NaturalEventDispatcher.NoLeading }} dispatcher{this};
      return HandleOneEventImpl_(client_end.channel(), event_storage.view(), dispatcher);
  }
{{- end }}

{{- if or .Events .HandlesOneWayUnknownInteractions }}
  ::fidl::Status
  {{ .NaturalEventDispatcher.NoLeading }}::DispatchEvent(
      ::fidl::IncomingHeaderAndMessage& msg,
      ::fidl::internal::MessageStorageViewBase* storage_view) {
    switch (msg.header()->ordinal) {
    {{- range .Events }}
      case {{ .OrdinalName }}:
      {
        ::fit::result decoded = ::fidl::internal::DecodeTransactionalMessage
              {{- if .HasResponsePayload }}<{{ .ResponsePayload }}>{{ end -}}(std::move(msg));
        if (decoded.is_error()) {
          return decoded.error_value();
        }
        if (event_handler()) {
          {{- if .HasResponsePayload }}
            {{ .NaturalEvent }} event = std::move(decoded.value())
          {{- end }};
          event_handler()->{{ .Name }}({{ if .HasResponsePayload }}event{{ end }});
        }
        return ::fidl::Status::Ok();
      }
    {{- end }}
      default:
        {{- if .HandlesOneWayUnknownInteractions }}
        auto* hdr = msg.header();
        ::fidl::UnknownMethodType unknown_method_type =
            ::fidl::internal::UnknownMethodTypeFromHeader(hdr);
        bool is_flexible_interaction = ::fidl::IsFlexibleInteraction(hdr);
        auto ordinal = hdr->ordinal;
        {{- end }}
        {{- /* Close handles regardless of whether there is an unknown interaction handler. */}}
        std::move(msg).CloseHandles();
        {{- if .HandlesOneWayUnknownInteractions }}
        if (is_flexible_interaction &&
            ::fidl::internal::CanHandleEvent({{ . }}::kOpenness, unknown_method_type)) {
          if (event_handler()) {
            {{ .UnknownEventMetadata }} metadata {
              .event_ordinal = ordinal,
            };
            event_handler()->handle_unknown_event(metadata);
          }
          return ::fidl::Status::Ok();
        }
        {{- end }}
        return ::fidl::Status::UnknownOrdinal();
    }
  }
{{- end }}

{{ .NaturalEventDispatcher }}::{{ .NaturalEventDispatcher.Self }}({{ .NaturalEventHandlerInterface }}* event_handler)
: IncomingEventDispatcher(event_handler) {}

{{- range .Events }}
void {{ $.NaturalAsyncEventHandler.NoLeading }}::{{ .Name }}({{ if .HasResponsePayload }}{{ .NaturalEvent }}&{{ end }}) {}
{{- end }}

{{- end }}