fn serialize_variant_body()

in sgx_serialize_derive/src/encode.rs [132:226]

• 93 lines of code
• 2 McCabe index (conditional complexity)

fn serialize_variant_body(
    cont: &Container,
    variant: &Variant,
    variant_index: usize
) -> Tokens {
    let name: syn::Ident = cont.ident.clone().into();
    let name_arg = fromat_ident(&name);
    let variant_ident = variant.ident.clone();
    let variant_ident_arg = fromat_ident(&variant_ident);

    let body = match variant.style {
        Style::Unit => {
            quote! { {
                    let _e = __arg_0;
                    _e.emit_enum(#name_arg,
                        |_e| -> _ {
                            _e.emit_enum_variant(#variant_ident_arg,
                                                #variant_index,
                                                0usize,
                                                |_e| -> _ {
                                                        return ::std::result::Result::Ok(())
                                                })
                            })
                }
            }
        }
        Style::Newtype => {
            quote! { {
                let _e = __arg_0;
                _e.emit_enum(#name_arg,
                    |_e| -> _ {
                        _e.emit_enum_variant(#variant_ident_arg,
                                            #variant_index,
                                            1usize,
                                            |_e| -> _ {
                                                return _e.emit_enum_variant_arg(
                                                        0usize,
                                                        |_e| -> _ {
                                                            ::sgx_serialize::Serializable::encode(&(*__self_0), _e)
                                                        })
                                            })
                    })
                }
            }
        }
        Style::Tuple => {
            let variant_fields_len = variant.fields.len();
            let variant_args: Vec<Tokens> =
                variant.fields
                .iter()
                .enumerate()
                .map(
                    |(i, _)| {
                        let id = Ident::new(format!("__self_{}", i));
                        if variant_fields_len == i+1 {
                            quote! {
                                return _e.emit_enum_variant_arg(#i,
                                                    |_e| -> _ {
                                                        ::sgx_serialize::Serializable::encode(&(*#id),
                                                                                        _e)})
                            }
                        } else {
                            quote! {
                                match _e.emit_enum_variant_arg(#i,
                                                    |_e| -> _ {
                                                        ::sgx_serialize::Serializable::encode(&(*#id),
                                                                                    _e)})
                                    {
                                    ::std::result::Result::Ok(__try_var) => __try_var,
                                    ::std::result::Result::Err(__try_var) => return ::std::result::Result::Err(__try_var),
                                }
                            }
                        }
                })
                .collect();
            quote! { {
                    let _e = __arg_0;
                    _e.emit_enum(#name_arg,
                        |_e| -> _ {
                            _e.emit_enum_variant(#variant_ident_arg,
                                                #variant_index, #variant_fields_len,
                                                |_e| -> _ {
                                                        #(#variant_args)*
                                                    })
                    })
                }
            }
        }
        Style::Struct => {
            serialize_variant_body_visitor(cont, variant, variant_index)
        }
    };

    quote! { #body }
}