{{/*
// Copyright 2019 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 "ServiceDeclaration" }}
#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct {{ .Name }}Marker;

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceMarker for {{ .Name }}Marker {
    type Proxy = {{ .Name }}Proxy;
    type Request = {{ .Name }}Request;
    const SERVICE_NAME: &'static str = "{{ .ServiceName }}";
}

/// A request for one of the member protocols of {{ .Name }}.
///
{{- range .DocComments }}
///{{ . }}
{{- end }}
#[cfg(target_os = "fuchsia")]
pub enum {{ .Name }}Request {
    {{- range .Members }}
    {{- if eq .Type.ProtocolTransport "Channel" }}
    {{- range .DocComments }}
    ///{{ . }}
    {{- end }}
    {{ .CamelName }}({{ .ProtocolType }}RequestStream),
    {{- end }}
    {{- end }}
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceRequest for {{ .Name }}Request {
    type Service = {{ .Name }}Marker;

    fn dispatch(name: &str, _channel: fidl::AsyncChannel) -> Self {
        match name {
            {{- range .Members }}
            {{- if eq .Type.ProtocolTransport "Channel" }}
            "{{ .Name }}" => Self::{{ .CamelName }}(
                <{{ .ProtocolType }}RequestStream as fidl::endpoints::RequestStream>::from_channel(_channel),
            ),
            {{- end }}
            {{- end }}
            _ => panic!("no such member protocol name for service {{ .Name }}"),
        }
    }

    fn member_names() -> &'static [&'static str] {
        &[
        {{- range .Members }}
        {{- if eq .Type.ProtocolTransport "Channel" }}
            "{{ .Name }}",
        {{- end }}
        {{- end }}
        ]
    }
}

{{- range .DocComments }}
///{{ . }}
{{- end }}
#[cfg(target_os = "fuchsia")]
pub struct {{ .Name }}Proxy(#[allow(dead_code)] Box<dyn fidl::endpoints::MemberOpener>);

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::ServiceProxy for {{ .Name }}Proxy {
    type Service = {{ .Name }}Marker;

    fn from_member_opener(opener: Box<dyn fidl::endpoints::MemberOpener>) -> Self {
        Self(opener)
    }
}

#[cfg(target_os = "fuchsia")]
impl {{ .Name }}Proxy {
    {{- range .Members }}
    {{- if eq .Type.ProtocolTransport "Channel" }}
    {{- range .DocComments }}
    ///{{ . }}
    {{- end }}
    pub fn connect_to_{{ .SnakeName }}(&self) -> Result<{{ .ProtocolType }}Proxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_proxy::<{{ .ProtocolType }}Marker>();
        self.connect_channel_to_{{ .SnakeName }}(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_{{ .SnakeName }}`, but returns a sync proxy.
    /// See [`Self::connect_to_{{ .SnakeName }}`] for more details.
    pub fn connect_to_{{ .SnakeName }}_sync(&self) -> Result<{{ .ProtocolType }}SynchronousProxy, fidl::Error> {
        let (proxy, server_end) = fidl::endpoints::create_sync_proxy::<{{ .ProtocolType }}Marker>();
        self.connect_channel_to_{{ .SnakeName }}(server_end)?;
        Ok(proxy)
    }

    /// Like `connect_to_{{ .SnakeName }}`, but accepts a server end.
    /// See [`Self::connect_to_{{ .SnakeName }}`] for more details.
    pub fn connect_channel_to_{{ .SnakeName }}(&self, server_end: fidl::endpoints::ServerEnd<{{ .ProtocolType }}Marker>) -> Result<(), fidl::Error> {
        self.0.open_member("{{ .Name }}", server_end.into_channel())
    }
    {{- end }}
    {{- end }}

    pub fn instance_name(&self) -> &str {
        self.0.instance_name()
    }
}
{{- end }}