tools/fidl/fidlgen_cpp/codegen/fragment_protocol_event_sender.tmpl

{{/*
// Copyright 2020 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:EventSender:WireMessagingHeader" }}
{{ EnsureNamespace "" }}
template<>
class {{ .WireWeakEventSender }} : public ::fidl::internal::WeakEventSenderBase {
 public:
  using WeakEventSenderBase::WeakEventSenderBase;
{{ "" }}

  {{- range .Events }}
    {{- .Docs }}
    fidl::OneWayStatus {{ .Name }}({{ RenderParams .ResponseArgs }});

{{ "" }}
  {{- end }}
};

template<>
class {{ .WireWeakBufferEventSender }} : public ::fidl::internal::WeakBufferEventSenderBase {
 public:
  using WeakBufferEventSenderBase::WeakBufferEventSenderBase;
{{ "" }}

  {{- range .Events }}
    {{- .Docs }}
    fidl::OneWayStatus {{ .Name }}({{ RenderParams .ResponseArgs }});

{{ "" }}
  {{- end }}
};

template<>
class {{ .WireEventSender }}
    : public ::fidl::internal::SyncEndpointManagedVeneer<{{ .WireEventSender }}> {
 public:
  using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer;
{{ "" }}

  {{- range .Events }}
    {{- .Docs }}
    fidl::OneWayStatus {{ .Name }}({{ RenderParams .ResponseArgs }});

{{ "" }}
  {{- end }}
};

template<>
class {{ .WireBufferEventSender }}
    : public ::fidl::internal::SyncEndpointBufferVeneer<{{ .WireBufferEventSender }}> {
 public:
  using SyncEndpointBufferVeneer::SyncEndpointBufferVeneer;
{{ "" }}

  {{- range .Events }}
    {{- .Docs }}
    fidl::OneWayStatus {{ .Name }}({{ RenderParams .ResponseArgs }});

{{ "" }}
  {{- end }}
};

{{- end }}

{{- define "Protocol:EventSender:WireMessagingSource" }}
{{ EnsureNamespace "" }}
  {{- range .Events }}

    {{- /* Weak, managed */}}
::fidl::OneWayStatus {{ $.WireWeakEventSender.NoLeading }}::{{ .Name }}(
    {{- RenderParams .ResponseArgs }}) {
  {{ .WireTransactionalEvent }} _response{ {{- RenderForwardParams .ResponseArgs }} };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<{{ .WireTransactionalEvent }}, {{ .Transport.Type }}> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}

    {{- /* Weak, caller-allocated */}}
{{ "" }}
fidl::OneWayStatus {{ $.WireWeakBufferEventSender.NoLeading }}::{{ .Name }}(
    {{- RenderParams .ResponseArgs }}) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<{{ .Marker }}>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    _inner().HandleSendError(_allocation.error_value());
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  {{ .WireTransactionalEvent }} _response{ {{- RenderForwardParams .ResponseArgs }} };
  ::fidl::internal::UnownedEncodedMessage<{{ .WireTransactionalEvent }}, {{ .Transport.Type }}> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _inner().SendEvent(_response_message.GetOutgoingMessage());
}
{{ "" }}

    {{- /* Managed */}}
fidl::OneWayStatus {{ $.WireEventSender.NoLeading }}::{{ .Name }}(
    {{- RenderParams .ResponseArgs }}) {
  {{ .WireTransactionalEvent }} _response{ {{- RenderForwardParams .ResponseArgs }} };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<{{ .WireTransactionalEvent }}, {{ .Transport.Type }}> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response
  };
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}

    {{- /* Caller-allocated */}}
{{ "" }}
fidl::OneWayStatus {{ $.WireBufferEventSender.NoLeading }}::{{ .Name }}(
    {{- RenderParams .ResponseArgs }}) {
  constexpr uint32_t _buffer_size = ::fidl::EventReplyBufferSizeInChannel<{{ .Marker }}>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    return fidl::OneWayStatus{_allocation.error_value()};
  }

  {{ .WireTransactionalEvent }} _response{ {{- RenderForwardParams .ResponseArgs }} };
  ::fidl::internal::UnownedEncodedMessage<{{ .WireTransactionalEvent }}, {{ .Transport.Type }}> _response_message(
        _allocation->data, _buffer_size, &_response);
  auto& _message = _response_message.GetOutgoingMessage();
  _message.Write(_transport());
  return ::fidl::OneWayStatus{::fidl::Status{_message}};
}
{{ "" }}

  {{- end }}
{{- end }}



{{- define "Protocol:EventSender:NaturalMessagingHeader" }}
{{ EnsureNamespace "" }}

template<>
class {{ .NaturalWeakEventSender }} : public ::fidl::internal::WeakEventSenderBase {
 public:
  using WeakEventSenderBase::WeakEventSenderBase;
{{ "" }}

  {{- range .Events }}
    {{- .Docs }}
    ::fit::result<::fidl::OneWayError> {{ .Name }}({{ .NaturalResponseArg "payload" }});

  {{ end }}
};

template<>
class {{ .NaturalEventSender }}
    : public ::fidl::internal::SyncEndpointManagedVeneer<{{ .NaturalEventSender }}> {
 public:
  using SyncEndpointManagedVeneer::SyncEndpointManagedVeneer;
{{ "" }}

  {{- range .Events }}
    {{- .Docs }}
    ::fit::result<::fidl::OneWayError> {{ .Name }}({{ .NaturalResponseArg "payload" }});

  {{ end }}
};

{{- end }}



{{- define "Protocol:EventSender:NaturalMessagingSource" }}
{{ EnsureNamespace "" }}
  {{- range .Events }}

::fit::result<::fidl::OneWayError> {{ $.NaturalWeakEventSender.NoLeading }}::{{ .Name }}(
    {{- .NaturalResponseArg "payload" }}) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, {{ .OrdinalName }}, {{ .DynamicFlagsName }} };
  {{- if .HasResponsePayload }}
  _encoder.EncodeBody({{ .Response.Forward "payload" }});
  {{- end }}
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  return ::fidl::internal::ToFitxResult(_inner().SendEvent(_encoded_message));
}

::fit::result<::fidl::OneWayError> {{ $.NaturalEventSender.NoLeading }}::{{ .Name }}(
    {{- .NaturalResponseArg "payload" }}) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, {{ .OrdinalName }}, {{ .DynamicFlagsName }} };
  {{- if .HasResponsePayload }}
  _encoder.EncodeBody({{ .Response.Forward "payload" }});
  {{- end }}
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  _encoded_message.Write(_transport());
  return ::fidl::internal::ToFitxResult(::fidl::OneWayStatus{::fidl::Status{_encoded_message}});
}

  {{ end }}
{{- end }}