基本用法

将 derive-ctor 添加到您的 Cargo.toml

[dependencies]
derive-ctor = "1.0.6"

使用 #[derive(ctor)] 注解您的结构体以自动生成一个 new 构造函数

use derive_ctor::ctor;

#[derive(ctor)]
struct MyStruct {
    field1: i32,
    field2: String
}

let my_struct = MyStruct::new(1, String::from("Foo"));

结构体配置

可见性和构造函数名称

您可以使用 #[ctor] 属性修改生成方法的名称和可见性，并在 ctor 派生后定义额外的构造函数。

在以下示例中，创建了三个构造函数方法： new、with_defaults 和 internal。这些方法都继承了 #[ctor] 属性中定义的相应可见性。

use derive_ctor::ctor;

#[derive(ctor)]
#[ctor(pub new, pub(crate) other, const internal)]
struct MyStruct {
    field1: i32,
    field2: String
}

let my_struct1 = MyStruct::new(100, "A".to_string());
let my_struct2 = MyStruct::other(200, "B".to_string());
let my_struct3 = MyStruct::internal(300, "C".to_string());

自动实现 "Default" 特性

可以通过在构造函数属性中指定名为 default 的构造函数来自动实现 Default 特性。注意：为了使实现有效，所有字段都必须具有生成的值。此外，声明 default(all) 将自动将所有未注解字段标记为 #[ctor(default)]

use derive_ctor::ctor;

#[derive(ctor)]
#[ctor(default)]
struct MyStruct {
    #[ctor(default)]
    field1: i32,
    #[ctor(expr(true))]
    field2: bool
}

let default: MyStruct = Default::default();


#[derive(ctor)]
#[ctor(default(all))]
struct OtherStruct {
    field1: i32,
    #[ctor(expr(true))]
    field2: bool
}

let default2: OtherStruct = Default::default();

构造函数属性

自定义构造函数定义还可以采取以下属性以在所有未配置的字段上实施

• default - 将所有未注解字段标记为 #[ctor(default)]
• 进入 - 标记所有未注释字段为 #[ctor(into)]

use derive_ctor::ctor;

#[derive(ctor)]
#[ctor(new(into), with_defaults(default))]
struct MyStruct {
    name: String,
    #[ctor(expr(13))]
    value: i32
}

let example1 = MyStruct::new("FooBar");
let example2 = MyStruct::with_defaults();

枚举和联合配置

默认情况下，将为每个变体生成一个构造函数。此构造函数默认将与各自的变体名称匹配，并且是公开的。可以通过注释枚举为 #[ctor(prefix = PREFIX, visibility = VISIBILITY)] 来更改此默认行为。请注意，在属性中这两个参数都是可选的。指定此属性将更改每个变体的默认生成方法，但每个变体还可以定义自己的配置，该配置将覆盖枚举中定义的配置。

标准变体构造函数示例

use derive_ctor::ctor;

#[derive(ctor)]
enum MyEnum {
    Variant1,
    Variant2(i32),
    Variant3 { value: bool }
}

let v1 = MyEnum::variant1();
let v2 = MyEnum::variant2(100);
let v3 = MyEnum::variant3(true);

配置的变体构造函数示例

变体构造函数配置与结构体构造函数配置相同。请参考以下示例语法，或返回到结构体构造函数配置以获取更多信息。

use derive_ctor::ctor;

#[derive(ctor)]
#[ctor(prefix = new, vis = pub(crate))]
enum MyEnum {
    #[ctor(const pub v1, other)]
    Variant1,
    Variant2,
    Variant3
}

const v1_1: MyEnum = MyEnum::v1();
let v1_2 = MyEnum::other();
let v2 = MyEnum::new_variant2();
let v3 = MyEnum::new_variant3();

如果一个变体使用 #[ctor(none)] 进行继承，则不会为其生成构造函数。同样，如果一个变体使用 #[ctor(default)] 进行继承，则将自动实现 Default 特性以生成该变体。

联合表达与枚举相同的行为，但适用于联合的字段而不是枚举的变体。

use derive_ctor::ctor;

#[derive(ctor)]
#[ctor(prefix = new, vis = pub(crate))]
union MyUnion {
    #[ctor(const new)]
    v1: i32,
    v2: f32,
    v3: u32
}

const VAL: MyUnion = MyUnion::new(100);
let v2 = MyUnion::new_v2(123.231);
let v3 = MyUnion::new_v3(414224); 

字段配置

字段也可以使用 #[ctor(PROPERTY)] 进行注释以更改生成方法中的行为。**这些配置适用于所有枚举类型和结构体！**以下是可以与字段属性一起使用的可用属性：

use derive_ctor::ctor;

#[derive(ctor)]
struct MyStruct {
    field1: i32,
    #[ctor(cloned)]
    field2: String
}

let string = String::from("Foo");
let my_struct = MyStruct::new(100, &string);

use derive_ctor::ctor;

#[derive(ctor)]
struct MyStruct {
    field1: i32,
    #[ctor(default)]
    field2: String
}

let my_struct = MyStruct::new(100);

use derive_ctor::ctor;

#[derive(ctor)]
struct MyStruct {
    field1: i32,
    #[ctor(into)] // the parameter type will now be impl Into<String> instead of String
    field2: String
}

let my_struct = MyStruct::new(100, "Foo");

use derive_ctor::ctor;

#[derive(ctor)]
struct MyStruct {
    field1: i32,
    #[ctor(expr(String::from("Foo")))]
    field2: String,
    #[ctor(expr!(field3 + 100))]
    field3: u32,
    #[ctor(expr(i32 -> field4 < 0))]
    field4: bool
}

let my_struct = MyStruct::new(100, 5, -20); // generates MyStruct { field1: 100, field2: "foo", field3: 105, field4: true }

use std::collections::HashSet;
use derive_ctor::ctor;

#[derive(ctor)]
struct MyStruct {
    field1: i32,
    #[ctor(iter(usize))]
    field2: HashSet<usize>
}

let my_struct = MyStruct::new(0, vec![1, 1, 2, 3, 4]);

use derive_ctor::ctor;

#[derive(ctor)]
#[ctor(new, with_defaults)]
struct MyStruct {
    field1: i32,
    #[ctor(default = [1])]
    field2: String,
    #[ctor(default = 1)] // brackets can be removed if specifying only 1 index
    field3: bool,
    #[ctor(default = [0, 1])]
    field4: u64,
    #[ctor(default)] // this is the same as specifying all indices
    field5: u64
}

let my_struct1 = MyStruct::new(100, "Foo".to_string(), true);
let my_struct2 = MyStruct::with_defaults(100);

use derive_ctor::ctor;

#[derive(ctor)]
struct MyStruct {
    #[expr(100)]
    value: u32
}

let my_struct = MyStruct::new();