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

  void Reply({{ .WireReplyArgs }});

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

 private:
  void MakeReply({{ RenderParams .ResponseArgs }});
};

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

  void Reply({{ .WireReplyArgs }});

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

 private:
  void MakeReply({{ RenderParams .ResponseArgs }});
};

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

  {{- /* Update `this` pointer after moving the completer. */}}
  {{ .WireCompleterBase.Self }}({{ .WireCompleterBase.Self }}&& other) noexcept;
  {{ .WireCompleterBase.Self }}& operator=({{ .WireCompleterBase.Self }}&& other) noexcept;
};

{{- end }}



{{- define "Method:CompleterBase:WireMessagingSource" }}
{{ EnsureNamespace "" }}

void
{{ .WireCompleterImpl.NoLeading }}::Reply({{ .WireReplyArgs }}) {
  {{- if .HasDomainError }}
  if (result.is_ok()) {
    return MakeReply({{ .WireReplySuccess "result.value()" }});
  }
  return ReplyError(std::move(result.error_value()));
  {{- else if .HasFrameworkError }}
  {{ .Result.BuildPayload "_response" -}}
  return MakeReply({{ .WireReplySuccess "&_response" }});
  {{- else }}
  return MakeReply({{ RenderForwardParams .ResponseArgs }});
  {{- end }}
}

void
{{ .WireCompleterImpl.NoLeading }}::MakeReply({{ RenderParams .ResponseArgs }}) {
  {{ .WireTransactionalResponse }} _response{ {{ RenderForwardParams .ResponseArgs }} };
  __UNINITIALIZED
  ::fidl::internal::OwnedEncodedMessage<
      {{ .WireTransactionalResponse }}, {{ .Transport.Type }}> _response_message{
      ::fidl::internal::AllowUnownedInputRef{}, &_response};
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

{{- if .HasDomainError }}
  void
  {{ .WireCompleterImpl.NoLeading }}::ReplySuccess({{ RenderParams .Result.ValueParameters }}) {
    {{ .Result.BuildPayload "_response" -}}
    return MakeReply({{ .WireReplySuccess "&_response" }});
  }

  void
  {{ .WireCompleterImpl.NoLeading }}::ReplyError({{ .Result.ErrorDecl }} error) {
    return MakeReply({{ .WireReplyError "error" }});
  }
{{- end }}


void
{{ .WireBufferCompleterImpl.NoLeading }}::Reply({{ .WireReplyArgs }}) {
  {{- if .HasDomainError }}
  if (result.is_ok()) {
    return MakeReply({{ .WireReplySuccess "result.value()" }});
  }
  return ReplyError(std::move(result.error_value()));
  {{- else if .HasFrameworkError }}
  {{ .Result.BuildPayload "_response" -}}
  return MakeReply({{ .WireReplySuccess "&_response" }});
  {{- else }}
  return MakeReply({{ RenderForwardParams .ResponseArgs }});
  {{- end }}
}

void
{{ .WireBufferCompleterImpl.NoLeading }}::MakeReply({{ RenderParams .ResponseArgs }}) {
  {{ .WireTransactionalResponse }} _response{ {{ RenderForwardParams .ResponseArgs }} };
  constexpr uint32_t _buffer_size = ::fidl::ServerReplyBufferSizeInChannel<{{ .Marker }}>();
  ::fit::result<::fidl::Error, ::fidl::BufferSpan> _allocation =
      _allocator().TryAllocate(_buffer_size);
  if (!_allocation.is_ok()) {
    ::fidl::OutgoingMessage _failure{_allocation.error_value()};
    return _core()->SendReply(&_failure, ::fidl::internal::OutgoingTransportContext());
  }
  ::fidl::internal::UnownedEncodedMessage<
      {{ .WireTransactionalResponse }}, {{ .Transport.Type }}> _response_message(
      _allocation->data, _buffer_size, &_response);
  return _core()->SendReply(&_response_message.GetOutgoingMessage(),
                            ::fidl::internal::OutgoingTransportContext());
}

{{ .WireCompleterBase.NoLeading }}::{{ .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.NoLeading }}::{{ .WireCompleterBase.Self }}({{ .WireCompleterBase.Self }}&& other) noexcept
    : CompleterBase(std::move(other)), {{ .WireCompleterImpl.Self }}(this) {}

{{ .WireCompleterBase }}& {{ .WireCompleterBase.NoLeading }}::operator=({{ .WireCompleterBase.Self }}&& other) noexcept {
  CompleterBase::operator=(std::move(other));
  {{ .WireCompleterImpl.Self }}::_set_core(this);
  return *this;
}


{{- if .HasDomainError }}
  void
  {{ .WireBufferCompleterImpl.NoLeading }}::ReplySuccess({{ RenderParams .Result.ValueParameters }}) {
    {{ .Result.BuildPayload "_response" -}}
    return MakeReply({{ .WireReplySuccess "&_response" }});
  }

  void
  {{ .WireBufferCompleterImpl.NoLeading }}::ReplyError({{ .Result.ErrorDecl }} error) {
    return MakeReply({{ .WireReplyError "error" }});
  }
{{- end }}


{{- end }}



{{- define "Method:CompleterBase:NaturalMessagingHeader" }}
{{ EnsureNamespace "" }}
template<>
class {{ .NaturalCompleterBase }} : public ::fidl::CompleterBase {
 public:
  void Reply({{ .NaturalResponseArg "response" }});

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

{{- end }}



{{- define "Method:CompleterBase:NaturalMessagingSource" }}
{{ EnsureNamespace "" }}
void {{ .NaturalCompleterBase.NoLeading }}::Reply(
    {{- .NaturalResponseArg "response" }}) {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::ChannelTransport::VTable, {{ .OrdinalName }}, {{ .DynamicFlagsName }} };
  {{- if .HasResponsePayload }}
    {{- if .HasResponseArgs }}
  _encoder.EncodeBody(
      {{ .NaturalResponseConverter }}::IntoDomainObject({{ .Response.Forward "response" }}));
    {{- else }}
  _encoder.EncodeBody({{ .Result.ResultDecl }}::WithResponse({}));
    {{- end }}
  {{- end }}
  ::fidl::OutgoingMessage _encoded_message = _encoder.GetMessage();
  SendReply(&_encoded_message, ::fidl::internal::OutgoingTransportContext{});
}
{{- end }}