{{/*
// Copyright 2018 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 "StructDeclaration" }}
{{- if EmitType .IsValueType }}
{{- range .DocComments }}
///{{ . }}
{{- end }}
{{ .Derives }}
{{- if .UseFidlStructCopy }}
#[repr(C)]
{{- end }}
pub struct {{ .Name }}{{ if not .Members }};{{ else }}{
    {{- range .Members }}
    {{- range .DocComments }}
    ///{{ . }}
    {{- end }}
    pub {{ .Name }}: {{ .Type.Owned }},
    {{- end }}
}
{{- end }}

impl fidl::{{ if .IsValueType }}Persistable{{ else }}Standalone<{{ ResourceDialect }}>{{ end }} for {{ .Name }} {}

{{- if .Serializable.IsSerializable }}
impl fidl::Serializable for {{ .Name }} {
      const SERIALIZABLE_NAME: &'static str = "{{ .Serializable.Name }}";
}
{{- end }}

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

{{- define "StructInternal" }}
{{- if EmitType .IsValueType }}
{{- $resourceDialectName := "D"}}
{{- $resourceDialectGeneric := "<D: fidl::encoding::ResourceDialect>"}}
{{- $resourceDialectGenericPart := "D: fidl::encoding::ResourceDialect, "}}
{{- if .IsResourceType }}
{{- $resourceDialectName = ResourceDialect}}
{{- $resourceDialectGeneric = ""}}
{{- $resourceDialectGenericPart = ""}}
impl fidl::encoding::ResourceTypeMarker for {{ .Name }} {
    type Borrowed<'a> = &'a mut Self;
    fn take_or_borrow<'a>(value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'a> {
        value
    }
}
{{- else }}
impl fidl::encoding::ValueTypeMarker for {{ .Name }} {
    type Borrowed<'a> = &'a Self;
    fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
        value
    }
}
{{- end }}

unsafe impl fidl::encoding::TypeMarker for {{ .Name }} {
    type Owned = Self;

    #[inline(always)]
    fn inline_align(_context: fidl::encoding::Context) -> usize {
        {{ .AlignmentV2 }}
    }

    #[inline(always)]
    fn inline_size(_context: fidl::encoding::Context) -> usize {
        {{ .SizeV2 }}
    }

    {{- if and .UseFidlStructCopy (not .FlattenedPaddingMarkersV2) }}
    #[inline(always)]
    fn encode_is_copy() -> bool {
        true
    }

    #[inline(always)]
    fn decode_is_copy() -> bool {
        true
    }
    {{- end }}
}


unsafe impl{{ $resourceDialectGeneric }} fidl::encoding::Encode<{{ .Name }}, {{ $resourceDialectName }}> for &{{ if .IsResourceType }}mut {{ end }}{{ .Name }} {
    #[inline]
    unsafe fn encode(self, encoder: &mut fidl::encoding::Encoder<'_, {{ $resourceDialectName }}>, offset: usize, _depth: fidl::encoding::Depth) -> fidl::Result<()> {
        encoder.debug_check_bounds::<{{ .Name }}>(offset);
        {{- if not .Members }}
            {{- /* Case #1: Empty struct */}}
            encoder.write_num(0u8, offset);
            Ok(())
        {{- else if .UseFidlStructCopy }}
            {{- /* Case #2: Encode/decode is copy */}}
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut {{ .Name }}).write_unaligned((self as *const {{ .Name }}).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
                {{- range .FlattenedPaddingMarkersV2 }}
                let padding_ptr = buf_ptr.offset({{ .Offset }}) as *mut u{{ .MaskBitWidth }};
                let padding_mask = {{ .Mask | printf "%#x" }}u{{ .MaskBitWidth }};
                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
                {{- end }}
            }
            Ok(())
        {{- else }}
            {{- /* Case #3: General case */}}
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<{{ .Name }}, {{ $resourceDialectName }}>::encode(
                (
                    {{- range .Members }}
                    {{- if .Type.IsResourceType }}
                    <{{ .Type.Fidl $resourceDialectName }} as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.{{ .Name }}),
                    {{- else }}
                    <{{ .Type.Fidl $resourceDialectName }} as fidl::encoding::ValueTypeMarker>::borrow(&self.{{ .Name }}),
                    {{- end }}
                    {{- end }}
                ),
                encoder, offset, _depth
            )
        {{- end }}
    }
}

{{- if .Members }}
unsafe impl<{{ $resourceDialectGenericPart }}{{ range $i, $member := .Members }} T{{ $i }}: fidl::encoding::Encode<{{ $member.Type.Fidl $resourceDialectName }}, {{ $resourceDialectName }}>,{{ end }}>
    fidl::encoding::Encode<{{ .Name }}, {{ $resourceDialectName }}> for ({{ range $i, $member := .Members }} T{{ $i }},{{ end }})
{
    #[inline]
    unsafe fn encode(self, encoder: &mut fidl::encoding::Encoder<'_, {{ $resourceDialectName }}>, offset: usize, depth: fidl::encoding::Depth) -> fidl::Result<()> {
        encoder.debug_check_bounds::<{{ .Name }}>(offset);
        // Zero out padding regions. There's no need to apply masks
        // because the unmasked parts will be overwritten by fields.
        {{- range .PaddingMarkersV2 }}
        unsafe {
            let ptr = encoder.buf.as_mut_ptr().add(offset).offset({{ .Offset }});
            (ptr as *mut u{{ .MaskBitWidth }}).write_unaligned(0);
        }
        {{- end }}
        // Write the fields.
        {{- range $i, $member := .Members }}
        self.{{ $i }}.encode(encoder, offset + {{ $member.OffsetV2 }}, depth)?;
        {{- end }}
        Ok(())
    }
}
{{- end }}

impl{{ $resourceDialectGeneric }} fidl::encoding::Decode<Self, {{ $resourceDialectName }}> for {{ .Name }} {
    #[inline(always)]
    fn new_empty() -> Self {
        Self {{ if .Members -}} {
            {{- range .Members}}
            {{ .Name }}: fidl::new_empty!({{ .Type.Fidl $resourceDialectName }}, {{ $resourceDialectName }}),
            {{- end }}
        }
        {{- end }}
    }

    #[inline]
    unsafe fn decode(&mut self, decoder: &mut fidl::encoding::Decoder<'_, {{ $resourceDialectName }}>, offset: usize, _depth: fidl::encoding::Depth) -> fidl::Result<()> {
        decoder.debug_check_bounds::<Self>(offset);
        {{- if not .Members }}
            {{- /* Case #1: Empty struct */}}
            match decoder.read_num::<u8>(offset) {
                0 => Ok(()),
                _ => Err(fidl::Error::Invalid),
            }
        {{- else if .UseFidlStructCopy }}
            {{- /* Case #2: Encode/decode is copy */}}
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            {{- range .FlattenedPaddingMarkersV2 }}
            let ptr = unsafe { buf_ptr.offset({{ .Offset }}) };
            let padval = unsafe { (ptr as *const u{{ .MaskBitWidth }}).read_unaligned() };
            let mask = {{ .Mask | printf "%#x" }}u{{ .MaskBitWidth }};
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + {{ .Offset }} + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            {{- end }}
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, {{ .SizeV2 }});
            }
            Ok(())
        {{- else }}
        {{- /* Case #3: General case */}}
            // Verify that padding bytes are zero.
            {{- range .PaddingMarkersV2 }}
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset({{ .Offset }}) };
            let padval = unsafe { (ptr as *const u{{ .MaskBitWidth }}).read_unaligned() };
            let mask = {{ .Mask | printf "%#x" }}u{{ .MaskBitWidth }};
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + {{ .Offset }} + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            {{- end }}
            {{- range .Members }}
            fidl::decode!({{ .Type.Fidl $resourceDialectName }}, {{ $resourceDialectName }}, &mut self.{{ .Name }}, decoder, offset + {{ .OffsetV2 }}, _depth)?;
            {{- end }}
            Ok(())
        {{- end }}
    }
}
{{- end }}
{{- end }}