Struct-Merge

!!! 已废弃 !!!

此项目已被 inter-struct 取代。

请考虑切换到该库，因为这个库不会得到任何更新。

!!! 已废弃 !!!

生成合并各种结构的代码。

此crate提供两个proc-macros来生成两个非常相似的特质。

/// Merge another struct into Self whilst consuming it.
/// 
/// The other trait is named `StructMergeRef` and merges other structs by reference.
pub trait StructMerge<Src> {
    /// Merge the given struct into self.
    fn merge(&mut self, src: Src);

    /// Nearly the same as `merge`, but any `Self::Option<T>` fields will only get merged, if the
    /// value of the field is `None`.
    fn merge_soft(&mut self, src: Src);
}

在使用此crate之前，请务必阅读 已知注意事项 部分！

示例

此示例展示了 struct_merge 宏的简单用法。

structs.rs：此示例中使用的结构体。

use struct_merge::struct_merge;

/// The target struct we'll merge into.
pub struct Target {
    pub normal: String,
    pub optional: Option<String>,
    /// This field won't be touched as the macro cannot find a
    /// respective `ignored` field in the `Mixed` struct.
    pub ignored: Option<String>,
}

/// A struct with both an identical and an optional field type.
/// Note that the path to `Target` must always a fully qualifying path.
#[struct_merge(crate::structs::Target)]
pub struct Mixed {
    pub normal: String,
    pub optional: Option<Option<String>>,
}

lib.rs

use struct_merge::prelude::*;

mod structs;
use structs::{Target, Mixed};

fn main() {
    let mut target = Target {
        normal: "target".to_string(),
        optional: Some("target".to_string()),
        ignored: "target".to_string(),
    };

    let mixed = Mixed {
        /// Has the same type as Target::normal
        normal: "mixed".to_string(),
        /// Wraps Target::optional in an Option
        optional: Some(Some("mixed".to_string())),
    };

    // Merge the `Mixed` struct into target.
    target.merge(mixed);
    // You can also call this:
    // mixed.merge_into(target);
    assert_eq!(target.normal, "mixed".to_string());
    assert_eq!(target.optional, Some("mixed".to_string()));
    assert_eq!(target.ignored, "target".to_string());
}

合并行为

以下将解释目标结构体单个字段的合并行为。目标字段的名称为 test。

merge 和 merge_ref

相同类型

struct Src {
    test: T
}
struct Target {
    test: T
}

这会将 src.test 合并到 target.test
目标.test=src.test

目标为可选

struct Src {
    test: T
}
struct Target {
    test: Option<T>
}

这会将 src.test 包装成 Option 并合并到 target.test
目标.test= Some(src.test);

源为可选

struct Src {
    test: Option<T>
}
struct Target {
    test: T
}

如果 src.test 是 Some，则只将 src.test 合并到 target.test：

if let Some(value) = src.test {
    target.test = value;
}

merge_soft 和 merge_ref_soft

如果 target.test 不是可选的

只要目标字段不是可选的，就不会被修改！

目标为可选

struct Src {
    test: T
}
struct Target {
    test: Option<T>
}

这会将 src.test 包装成 Option 并合并到 target.test，但只有当 target.test 是 None

if target.test.is_none() {
    target.test = Some(src.test);
}

struct Src {
    test: Option<T>
}
struct Target {
    test: Option<T>
}

if target.test.is_none() {
    target.test = src.test;
}