Struct syn_args::Transform

source ·

pub struct Transform<'a> {
    pub value: &'a Value,
    pub key: &'a str,
}

Fields§

§value: &'a Value§key: &'a str

Implementations§

source §

impl<'a> Transform<'a>

source

pub fn new(value: &'a Value, key: &'a str) -> Self

Examples found in repository ?

examples/test-expand.rs (line 139)

    fn try_from(v: &syn_args::Value) -> Result<Self, Self::Error> {
        if let syn_args::Value::Object(_) = v {
            return Ok(ModuleSubObj {
                global: syn_args::Transform::new(v, "global").try_into()?,
                imports: syn_args::Transform::new(v, "imports").try_into()?,
                sub: syn_args::Transform::new(v, "sub").try_into()?,
            });
        }
        Err(Self::Error::new(proc_macro2::Span::call_site(), "Invalid args"))
    }
}
impl TryFrom<syn_args::Value> for ModuleSubObj {
    type Error = syn::Error;
    fn try_from(v: syn_args::Value) -> Result<Self, Self::Error> {
        ModuleSubObj::try_from(&v)
    }
}
impl syn_args::ArgsParse for ModuleSubObj {
    fn parse(input: &str) -> Result<Self, syn::Error> {
        syn_args::Formal::new().parse(input)?.try_into()
    }
}
impl TryFrom<syn_args::Transform<'_>> for ModuleSubObj {
    type Error = syn::Error;
    fn try_from(value: syn_args::Transform) -> Result<Self, Self::Error> {
        if let syn_args::Value::Object(obj) = value.value {
            if let Some(v) = obj.get(value.key) {
                return Ok(v.try_into()?);
            }
        }
        Err(Self::Error::new(proc_macro2::Span::call_site(), "Expected SubWrap"))
    }
}
pub struct Sub {
    pub value: def::Bool,
}
#[automatically_derived]
impl ::core::fmt::Debug for Sub {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field1_finish(f, "Sub", "value", &&self.value)
    }
}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for Sub {}
#[automatically_derived]
impl ::core::cmp::PartialEq for Sub {
    #[inline]
    fn eq(&self, other: &Sub) -> bool {
        self.value == other.value
    }
}
impl TryFrom<&syn_args::Value> for Sub {
    type Error = syn::Error;
    fn try_from(v: &syn_args::Value) -> Result<Self, Self::Error> {
        if let syn_args::Value::Object(_) = v {
            return Ok(Sub { value: syn_args::Transform::new(v, "value").try_into()? });
        }
        Err(Self::Error::new(proc_macro2::Span::call_site(), "Invalid args"))
    }
}
impl TryFrom<syn_args::Value> for Sub {
    type Error = syn::Error;
    fn try_from(v: syn_args::Value) -> Result<Self, Self::Error> {
        Sub::try_from(&v)
    }
}
impl syn_args::ArgsParse for Sub {
    fn parse(input: &str) -> Result<Self, syn::Error> {
        syn_args::Formal::new().parse(input)?.try_into()
    }
}
impl TryFrom<syn_args::Transform<'_>> for Sub {
    type Error = syn::Error;
    fn try_from(value: syn_args::Transform) -> Result<Self, Self::Error> {
        if let syn_args::Value::Object(obj) = value.value {
            if let Some(v) = obj.get(value.key) {
                return Ok(v.try_into()?);
            }
        }
        Err(Self::Error::new(proc_macro2::Span::call_site(), "Expected SubWrap"))
    }
}
pub struct SubWrap {
    pub s1: Sub,
    pub s2: Sub,
}
#[automatically_derived]
impl ::core::fmt::Debug for SubWrap {
    #[inline]
    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
        ::core::fmt::Formatter::debug_struct_field2_finish(f, "SubWrap", "s1", &self.s1, "s2", &&self.s2)
    }
}
#[automatically_derived]
impl ::core::marker::StructuralPartialEq for SubWrap {}
#[automatically_derived]
impl ::core::cmp::PartialEq for SubWrap {
    #[inline]
    fn eq(&self, other: &SubWrap) -> bool {
        self.s1 == other.s1 && self.s2 == other.s2
    }
}
impl TryFrom<&syn_args::Value> for SubWrap {
    type Error = syn::Error;
    fn try_from(v: &syn_args::Value) -> Result<Self, Self::Error> {
        if let syn_args::Value::Object(_) = v {
            return Ok(SubWrap { s1: syn_args::Transform::new(v, "s1").try_into()?, s2: syn_args::Transform::new(v, "s2").try_into()? });
        }
        Err(Self::Error::new(proc_macro2::Span::call_site(), "Invalid args"))
    }