#[fluent_impl_opts] 属性选项

(inblock, non_public, skip, prefix, rename, name, doc)

传递给覆盖块级默认值或设置方法特定配置的选项。

与#[fluent_impl]不同，此属性

1. 适用于方法而不是实现块。
2. 如果您愿意，可以多次传递给同一方法。

示例

#[fluent_impl]
impl Simple {
    #[fluent_impl_opts(non_public, inblock)]
    #[fluent_impl_opts(prefix="chain_", rename="added_1")]
    fn add_1(&mut self) {
        // ...
    }
}

选项

继承

• inblock (默认：继承)

  如果块尚未设置inblock，则为此特定方法设置inblock。

• non_public (默认：继承)

  如果块尚未设置non_public，则为此特定方法设置non_public。

  这允许为特定的私有方法或部分公开的方法（例如 pub(crate) 方法）生成链式方法。

• prefix（默认：继承）

  覆盖默认值或已设置的块值。

  • prefix不允许为空字符串。
  • 如果设置了name（见下文），则不允许设置方法特定的prefix。

• doc（默认：继承）

  覆盖默认值或已设置的块值。

方法特定

• skip（默认：未设置）

  跳过此方法。不要从中生成任何内容。

• rename（默认：可链式名称）

  默认链式方法名称是附加到可链式方法名称的前缀。此选项允许您重命名要添加到前缀的名称。

  • rename不允许为空字符串。
  • rename不允许设置，如果name（见下文）已设置，反之亦然。

• name（默认：未设置）

  设置链式方法名称。

  • name不允许设置，如果方法特定的prefix或rename已设置。

完整示例

extern crate fluent_impl;

pub mod m {
    use fluent_impl::{fluent_impl, fluent_impl_opts};
    use std::borrow::Borrow;
    use std::ops::AddAssign;

    #[derive(PartialEq, Debug)]
    pub struct TCounter(pub u32);

    #[derive(PartialEq, Debug)]
    pub struct St<A: AddAssign> {
        value: A,
        text: String,
    }

    #[fluent_impl]
    // impl block with generic arguments works
    impl<A: AddAssign> St<A> {
        // Constants (or any other items) in impl block are okay
        pub(crate) const C_TC: u32 = 100;

        pub fn new(value: A, text: String) -> Self {
            Self { value, text }
        }

        pub fn get_value(&self) -> &A {
            &self.value
        }

        pub fn get_text(&self) -> &str {
            &self.text
        }

        #[fluent_impl_opts(rename = "added_value")]
        // Destructuring patterns in method arguments are okay
        pub fn add_value(
            &mut self,
            to_be_added: A,
            TCounter(counter): &mut TCounter,
        ) {
            self.value += to_be_added;
            *counter += 1;
        }

        #[fluent_impl_opts(rename = "appended_text")]
        // Generic method arguments are okay
        pub fn append_text<S: Borrow<str>>(&mut self, arg: S) {
            self.text += arg.borrow();
        }

        #[fluent_impl_opts(rename = "appended_text_impl_trait")]
        // Needless to say, impl Trait method arguments are also okay
        pub fn append_text_impl_trait(&mut self, arg: impl Borrow<str>) {
            self.text += arg.borrow();
        }
    }
}

fn main() {
    use m::{St, TCounter};
    // ========
    let mut tc1 = TCounter(St::<u32>::C_TC);
    let mut s1 = St::new(0u32, "".into());
    s1.append_text("simple ");
    s1.append_text::<&str>("turbo fish ");
    s1.append_text_impl_trait("impl trait");
    s1.add_value(5, &mut tc1);
    assert_eq!(s1.get_text(), "simple turbo fish impl trait");
    assert_eq!(tc1, TCounter(St::<u32>::C_TC + 1));
    // ========
    let mut tc2 = TCounter(St::<u32>::C_TC);
    let s2 = St::new(0u32, "".into())
        .with_appended_text("simple ")
        .with_appended_text::<&str>("turbo fish ")
        .with_appended_text_impl_trait("impl trait")
        .with_added_value(5, &mut tc2);
    assert_eq!(s2, s1);
    assert_eq!(tc2, tc1);
}