planus-codegen 1.3.0

{% for docstring in docstrings.iter_strings() %}
/// {{ docstring }}
{%- endfor %}
#[derive(Clone, Debug, PartialEq, PartialOrd,
{% if info.should_do_eq %}Eq, Ord, Hash,{% endif %}
::serde::Serialize, ::serde::Deserialize)]
pub enum {{ info.owned_name }}{
    {% for variant in variants -%}
        {% for docstring in variant.name_and_docs.docstrings.iter_strings() %}
        /// {{ docstring }}
        {%- endfor %}
        {{ variant.enum_name }}({{ variant.owned_type }}),
    {% endfor %}
}

{% if !variants.is_empty() %}
impl {{info.owned_name}} {
    /// Creates a [{{info.builder_name}}] for serializing an instance of this table.
    #[inline]
    pub fn builder() -> {{info.builder_name}}<::planus::Uninitialized> {
        {{info.builder_name}}(::planus::Uninitialized)
    }

    {% for variant in variants -%}
    #[inline]
    pub fn {{variant.create_name}}(
      builder: &mut ::planus::Builder,
      value: impl ::planus::{{variant.create_trait}},
    ) -> ::planus::UnionOffset<Self> {
        ::planus::UnionOffset::new({{loop.index}}, value.prepare(builder).downcast())
    }

    {% endfor %}
}
{% endif %}

{% if variants.is_empty() %}
impl ::planus::WriteAsUnion<{{info.owned_name}}> for {{info.owned_name}} {
    #[inline]
    fn prepare(&self, _builder: &mut ::planus::Builder) -> ::planus::UnionOffset<Self> {
        match *self {}
    }
}
{% else %}
impl ::planus::WriteAsUnion<{{info.owned_name}}> for {{info.owned_name}} {
    #[inline]
    fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset<Self> {
        match self {
            {% for variant in variants -%}
                Self::{{ variant.enum_name }}(value) => Self::{{variant.create_name}}(builder, value),
            {% endfor %}
        }
    }
}
{% endif %}

impl ::planus::WriteAsOptionalUnion<{{info.owned_name}}> for {{info.owned_name}} {
    #[inline]
    fn prepare(&self, builder: &mut ::planus::Builder) -> ::core::option::Option<::planus::UnionOffset<Self>> {
        ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder))
    }
}

/// Builder for serializing an instance of the [{{info.owned_name}}] type.
///
/// Can be created using the [{{info.owned_name}}::builder] method.
#[derive(Debug)]
#[must_use]
pub struct {{ info.builder_name }}<T>(T);

impl {{ info.builder_name }}<::planus::Uninitialized> {
    {% for variant in variants -%}
    /// Creates an instance of the [`{{variant.name_and_docs.original_name}}` variant]({{info.owned_name}}#variant.{{variant.enum_name}}).
    #[inline]
    pub fn {{variant.builder_name}}<T>(
        self,
        value: T,
    ) -> {{ info.builder_name }}<::planus::Initialized<{{loop.index}}, T>>
        where T: ::planus::{{variant.create_trait}} {
        {{ info.builder_name }}(::planus::Initialized(value))
    }

    {% endfor %}
}

impl<const N: u8, T> {{ info.builder_name }}<::planus::Initialized<N, T>> {
    /// Finish writing the builder to get an [UnionOffset](::planus::UnionOffset) to a serialized [{{info.owned_name}}].
    #[inline]
    pub fn finish(self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset<{{ info.owned_name }}>
        where Self: ::planus::WriteAsUnion<{{info.owned_name}}>
    {
        ::planus::WriteAsUnion::prepare(&self, builder)
    }
}

{% for variant in variants -%}
impl<T> ::planus::WriteAsUnion<{{info.owned_name}}> for {{info.builder_name}}<::planus::Initialized<{{loop.index}}, T>>
    where T: ::planus::{{variant.create_trait}}
{
    #[inline]
    fn prepare(&self, builder: &mut ::planus::Builder) -> ::planus::UnionOffset<{{info.owned_name}}> {
        ::planus::UnionOffset::new({{loop.index}}, (self.0).0.prepare(builder).downcast())
    }
}

impl<T> ::planus::WriteAsOptionalUnion<{{info.owned_name}}> for {{info.builder_name}}<::planus::Initialized<{{loop.index}}, T>>
    where T: ::planus::{{variant.create_trait}}
{
    #[inline]
    fn prepare(&self, builder: &mut ::planus::Builder) -> ::core::option::Option<::planus::UnionOffset<{{info.owned_name}}>> {
        ::core::option::Option::Some(::planus::WriteAsUnion::prepare(self, builder))
    }
}
{% endfor %}

/// Reference to a deserialized [{{info.owned_name}}].
#[derive(Copy, Clone, Debug
{%- if info.should_do_infallible_conversion -%}
  , PartialEq, PartialOrd
  {%- if info.should_do_eq -%}, Eq, Ord, Hash{%- endif -%}
{%- endif -%}
)]
pub enum {{ info.ref_name_with_lifetime }}{
    {% for variant in variants -%}
        {{ variant.enum_name }}({{ variant.ref_type }}),
    {% endfor %}
}

{% if variants.is_empty() %}
impl ::core::convert::From<{{info.ref_name}}> for {{info.owned_name}} {
    #[inline]
    fn from(value: {{info.ref_name}}) -> Self {
        match value {}
    }
}
{% else if info.should_do_infallible_conversion %}
    impl<'a> ::core::convert::From<{{info.ref_name}}<'a>> for {{info.owned_name}} {
        fn from(value: {{info.ref_name}}<'a>) -> Self {
            match value {
                {% for variant in variants -%}
                    {% if variant.owned_type.starts_with("::planus::alloc::boxed::Box<") %}
                    {{info.ref_name}}::{{ variant.enum_name }}(value) => Self::{{variant.enum_name}}(::planus::alloc::boxed::Box::new(::core::convert::From::from(value))),
                    {% else %}
                    {{info.ref_name}}::{{ variant.enum_name }}(value) => Self::{{variant.enum_name}}(::core::convert::From::from(value)),
                    {% endif %}
                {% endfor %}
            }
        }
    }
{% else %}
impl<'a> ::core::convert::TryFrom<{{info.ref_name}}<'a>> for {{info.owned_name}} {
    type Error = ::planus::Error;

    fn try_from(value: {{info.ref_name}}<'a>) -> ::planus::Result<Self> {
        ::core::result::Result::Ok(match value {
            {% for variant in variants -%}
                {% if variant.owned_type.starts_with("::planus::alloc::boxed::Box<") %}
                {{info.ref_name}}::{{ variant.enum_name }}(value) => Self::{{variant.enum_name}}(::planus::alloc::boxed::Box::new(::core::convert::TryFrom::try_from(value)?)),
                {% else if variant.can_do_infallible_conversion %}
                {{info.ref_name}}::{{ variant.enum_name }}(value) => Self::{{variant.enum_name}}(::core::convert::From::from(value)),
                {% else %}
                {{info.ref_name}}::{{ variant.enum_name }}(value) => Self::{{variant.enum_name}}(::core::convert::TryFrom::try_from(value)?),
                {% endif %}
            {% endfor %}
        })
    }
}
{% endif %}

{% if variants.is_empty() %}
impl<'a> ::planus::TableReadUnion<'a> for {{info.ref_name}} {
    #[inline]
    fn from_buffer(_buffer: ::planus::SliceWithStartOffset<'a>, tag: u8, _field_offset: usize) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
        ::core::result::Result::Err(::planus::errors::ErrorKind::UnknownUnionTag { tag })
    }
}
{% else %}
impl<'a> ::planus::TableReadUnion<'a> for {{info.ref_name}}<'a> {
    fn from_buffer(buffer: ::planus::SliceWithStartOffset<'a>, tag: u8, field_offset: usize) -> ::core::result::Result<Self, ::planus::errors::ErrorKind> {
        match tag {
            {% for variant in variants -%}
                {%- if variant.is_struct -%}
                    {{loop.index}} => {
                        let struct_offset: u32 = ::planus::TableRead::from_buffer(buffer, field_offset)?;
                        ::core::result::Result::Ok(Self::{{ variant.enum_name }}(::planus::TableRead::from_buffer(buffer, field_offset + struct_offset as usize)?))
                    }
                {%- else -%}
                    {{loop.index}} => ::core::result::Result::Ok(Self::{{ variant.enum_name }}(::planus::TableRead::from_buffer(buffer, field_offset)?)),
                {%- endif -%}
            {%- endfor -%}
            _ => ::core::result::Result::Err(::planus::errors::ErrorKind::UnknownUnionTag { tag }),
        }
    }
}
{% endif %}

{% if variants.is_empty() %}
impl<'a> ::planus::VectorReadUnion<'a> for {{info.ref_name}} {
    const VECTOR_NAME: &'static str = "[{{info.ref_name}}]";
}
{% else %}
impl<'a> ::planus::VectorReadUnion<'a> for {{info.ref_name}}<'a> {
    const VECTOR_NAME: &'static str = "[{{info.ref_name}}]";
}
{% endif %}