tools/fidl/fidlgen_cpp/codegen/driver/fragment_protocol_client_impl.tmpl

{{/*
// Copyright 2022 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:ClientImpl:driver/MessagingHeader" }}
{{- EnsureNamespace "" }}

template<>
class {{ .WireWeakOnewayBufferClientImpl }} : public ::fdf::internal::BufferClientImplBase {
 public:
  using BufferClientImplBase::BufferClientImplBase;

  {{- range .OneWayMethods }}
    {{- template "Method:ClientImplOnewayBuffer:driver/MessagingHeader" . }}
  {{- end }}
};

template<>
class {{ .WireWeakAsyncBufferClientImpl }} final : public {{ .WireWeakOnewayBufferClientImpl }} {
 public:
  using {{ .WireWeakOnewayBufferClientImpl.Self }}::{{ .WireWeakOnewayBufferClientImpl.Self }};

  {{- range .TwoWayMethods }}
    {{- template "Method:ClientImplAsyncBuffer:driver/MessagingHeader" . }}
  {{- end }}
};

template<>
class {{ .WireWeakOnewayClientImpl }} : public ::fidl::internal::ClientImplBase {
 public:
  WireWeakOnewayClientImpl(fidl::internal::ClientBase* client_base, const fdf::Arena& arena)
    : ClientImplBase(client_base), arena_(arena) {}

  {{- range .OneWayMethods }}
    {{- template "Method:WireWeakOnewayClientImpl:driver/WireMessagingHeader" . }}
  {{- end }}

  protected:
  const ::fdf::Arena& arena_;
};

template<>
class {{ .WireWeakSyncClientImpl }} final : public {{ .WireWeakOnewayClientImpl }} {
 public:
  using {{ .WireWeakOnewayClientImpl.Self }}::{{ .WireWeakOnewayClientImpl.Self }};

  {{- range .TwoWayMethods }}
    {{- template "Method:WireWeakSyncClientImpl:driver/WireMessagingHeader" . }}
  {{- end }}
};

{{- end }}



{{- define "Protocol:ClientImpl:driver/MessagingSource" }}
  {{ EnsureNamespace ""}}

  {{- range .OneWayMethods }}
    {{- template "Method:WireWeakOnewayClientImpl:driver/WireMessagingSource" . }}
  {{- end }}
  {{- range .OneWayMethods }}
    {{- template "Method:ClientImplOnewayBuffer:driver/MessagingSource" . }}
  {{- end }}
  {{- range .TwoWayMethods }}
    {{- template "Method:ClientImplAsyncBuffer:driver/MessagingSource" . }}
  {{- end }}

  {{- range .TwoWayMethods }}
    {{- template "Method:WireWeakSyncClientImpl:driver/WireMessagingSource" . }}
  {{- end }}

{{- end }}


{{- define "Protocol:Client:driver/NaturalMessagingHeader" }}

{{- range .TwoWayMethods }}

{{- template "Method:Response:NaturalMessagingHeader" . }}

{{- EnsureNamespace "" }}
template <>
class {{ .NaturalResult }} final : public {{ .NaturalResultBase }} {
 public:
  using {{ .NaturalResultBase }}::result;

 protected:
  {{ .NaturalResult.Self }}() = default;
};
{{ end }}

{{- EnsureNamespace "" }}
template<>
class {{ .NaturalClientImpl }} final : public ::fidl::internal::NaturalClientBase {
 public:
  using NaturalClientBase::NaturalClientBase;

  {{- range .TwoWayMethods }}
  {{- .Docs }}
  {{ .NaturalThenable }} {{ .Name }}({{ .NaturalRequestArg "request" }}) const;
{{ "" }}
  {{- end }}

  {{- range .OneWayMethods }}
  {{- .Docs }}
  ::fit::result<::fidl::OneWayError> {{ .Name }}({{ .NaturalRequestArg "request" }}) const;
{{ "" }}
  {{- end }}
};

{{- end }}



{{- define "Protocol:Client:driver/NaturalMessagingSource" }}

{{- range .TwoWayMethods }}

{{- template "Method:Response:NaturalMessagingSource" . }}

{{- EnsureNamespace "" }}
{{ .NaturalThenable }}
{{ $.NaturalClientImpl.NoLeading }}::{{ .Name }}({{ .NaturalRequestArg "request" }}) const {
  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  return {{ .NaturalThenable }}(
      &client_base(), std::move(_options), &::fidl::internal::DriverTransport::VTable, {{ .OrdinalName }}, {{ .DynamicFlagsName }},
      [{{ if .HasRequestPayload }}request = {{ .Request.Forward "request" }}{{ end }}](NaturalMessageEncoder& encoder) mutable {
        {{- if .HasRequestPayload }}
        encoder.EncodeBody({{ .Request.Forward "request" }});
        {{- end }}
      },
      [arena = std::move(_arena)] (
          ::fidl::internal::ThenableBase* base,
          ::fidl::internal::NaturalMessageEncoder& encoder,
          ::fidl::internal::ResponseContext* response_context
      ) {
        ::fidl::OutgoingMessage msg = encoder.GetMessage();
        ::fidl::OutgoingMessage arena_msg = ::fdf::internal::MoveToArena(msg, arena);
        return base->SendTwoWay(arena_msg, response_context);
      });
}

{{ end }}

{{- range .OneWayMethods }}

{{- EnsureNamespace "" }}
::fit::result<::fidl::OneWayError>
{{ $.NaturalClientImpl.NoLeading }}::{{ .Name }}({{ .NaturalRequestArg "request" }}) const {
  ::fidl::internal::NaturalMessageEncoder _encoder{
      &::fidl::internal::DriverTransport::VTable, {{ .OrdinalName }}, {{ .DynamicFlagsName }} };

  fdf::Arena _arena('FIDL');

  ::fidl::WriteOptions _options = {
    .outgoing_transport_context =
      ::fidl::internal::OutgoingTransportContext::Create<::fidl::internal::DriverTransport>(_arena.get()),
  };
  {{- if .HasRequestPayload }}
  _encoder.EncodeBody({{ .Request.Forward "request" }});
  {{- end }}
  ::fidl::OutgoingMessage _msg = _encoder.GetMessage();
  ::fidl::OutgoingMessage _arena_msg = ::fdf::internal::MoveToArena(_msg, _arena);
  ::fidl::OneWayStatus status = client_base().SendOneWay(_arena_msg, std::move(_options));
  return ::fidl::internal::ToFitxResult(status);
}
{{ end }}

{{- end }}