tools/fidl/fidlgen_llcpp/codegen/driver/fragment_method_completer_base.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 "Method:CompleterBase:driver/WireMessagingHeader" }}
{{ EnsureNamespace "" }}
template<>
class {{ .WireCompleterImpl }} : public ::fdf::internal::CompleterImplBase<{{ .Marker }}> {
 public:
  using CompleterImplBase::CompleterImplBase;

  {{- /* Managed flavors are for now omitted from driver messaging. */}}
};

template <>
class {{ .WireBufferCompleterImpl }} : public ::fdf::internal::BufferCompleterImplBase {
 public:
  using BufferCompleterImplBase::BufferCompleterImplBase;

  void Reply({{ RenderParams .ResponseArgs }});

  {{- if .Result }}
  void ReplySuccess({{ RenderParams .Result.ValueParameters }});
  void ReplyError({{ .Result.ErrorDecl }} error);
  {{- end }}
};

template<>
class {{ .WireCompleterBase }} : public ::fidl::CompleterBase, public {{ .WireCompleterImpl }} {
 public:
  {{ .WireCompleterBase.Self }}(::fidl::Transaction* transaction, bool owned, bool expects_reply)
      : CompleterBase(transaction, owned, expects_reply),
        {{ .WireCompleterImpl.Self }}(this) {}

  {{- /* Update `this` pointer after moving the completer. */}}
  {{ .WireCompleterBase.Self }}({{ .WireCompleterBase.Self }}&& other) noexcept
      : CompleterBase(std::move(other)), {{ .WireCompleterImpl.Self }}(this) {}
  {{ .WireCompleterBase.Self }}& operator=({{ .WireCompleterBase.Self }}&& other) noexcept {
    CompleterBase::operator=(std::move(other));
    {{ .WireCompleterImpl.Self }}::_set_core(this);
    return *this;
  }
};

{{- end }}



{{- define "Method:CompleterBase:driver/WireMessagingSource" }}
{{ EnsureNamespace "" }}
{{- IfdefFuchsia -}}

void
{{ .WireBufferCompleterImpl.NoLeading }}::Reply({{ RenderParams .ResponseArgs }}) {
  {{ .WireTransactionalResponse }} _response{ {{ RenderForwardParams .ResponseArgs }} };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<{{ .Marker }}>();
  uint8_t* _buffer = static_cast<uint8_t*>(_arena().Allocate(_buffer_size));
  ::fidl::unstable::UnownedEncodedMessage<
      {{ .WireTransactionalResponse }}, {{ .Transport.Type }}> _response_message(
      _buffer, _buffer_size, &_response);
  return _core()->SendReply(
      &_response_message.GetOutgoingMessage(),
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(
          _arena().get()));
}

{{- if .Result }}
  void
  {{ .WireBufferCompleterImpl.NoLeading }}::ReplySuccess(
      {{- RenderParams .Result.ValueParameters }}) {
    {{ .Result.BuildPayload "_response" -}}

    {{- if .Result.Value.InlineInEnvelope }}
    return Reply({{ .Result.ResultDecl }}::WithResponse(std::move(_response)));
    {{- else }}
    return Reply({{ .Result.ResultDecl }}::WithResponse(
        ::fidl::ObjectView<{{ .Result.ValueTypeDecl }}>::FromExternal(&_response)));
    {{- end }}
  }

  void
  {{ .WireBufferCompleterImpl.NoLeading }}::ReplyError({{ .Result.ErrorDecl }} error) {
    {{- if .Result.Error.InlineInEnvelope }}
    return Reply({{ .Result.ResultDecl }}::WithErr(std::move(error)));
    {{- else }}
    return Reply({{ .Result.ResultDecl }}::WithErr(
        ::fidl::ObjectView<{{ .Result.ErrorDecl }}>::FromExternal(&error)));
    {{- end }}
  }
{{- end }}

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


{{- define "Method:CompleterBase:driver/NaturalMessagingHeader" }}
{{ EnsureNamespace "" }}
template<>
class {{ .NaturalCompleterBase }} : public ::fidl::CompleterBase {
 public:
  void Reply({{ template "Method:NaturalReplySignature:Helper" . }});

 protected:
  using ::fidl::CompleterBase::CompleterBase;
};

{{- end }}



{{- define "Method:CompleterBase:driver/NaturalMessagingSource" }}
{{ EnsureNamespace "" }}
void {{ .NaturalCompleterBase.NoLeading }}::Reply(
    {{- template "Method:NaturalReplySignature:Helper" . }}) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, {{ .OrdinalName }}, {{ .DynamicFlagsName }} };

  auto _arena = fdf::Arena::Create(0, "");
  if (!_arena.is_ok()) {
    ::fidl::OutgoingMessage _failure{::fidl::Status::TransportError(_arena.status_value())};
    SendReply(&_failure, {});
    return;
  }

  ::fidl::internal::OutgoingTransportContext _context =
    ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena->get());
  {{- if .HasResponsePayload }}
  _encoder.EncodeBody(
      {{ .NaturalResponseConverter }}::IntoDomainObject(std::move(response)));
  {{- end }}
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, *_arena);
  SendReply(&_arena_msg, std::move(_context));
}
{{- end }}