crate ownable

用于具有 Cow 的结构体/枚举的派生宏

自动将 Type<'a> 转换为 Type<'static> 以及更多。

示例

这对于使用 serde 借用的类型非常有帮助。

#[derive(IntoOwned, ToBorrowed, ToOwned)]
// #[derive(serde::Serialize, serde::Deserialize)]
pub struct Type<'a> {
  // #[serde(borrow)]
  cow: Cow<'a, str>,
  #[ownable(clone)] owned: String, // always clone this field
}

将派生类似于以下功能

impl Type<'_> {
  /// Copy the structure and clone the original values if it's not owned.
  /// This is always a deep copy of the structure.
  pub fn into_owned(self) -> Type<'static> {
    Type {
      cow: Cow::Owned(Cow::into_owned(self.cow)),
      owned: self.owned.clone(), // always cloned, as requested
    }
  }
  /// Copy the structure and clone the original values.
  /// This is always a deep copy.
  pub fn to_owned(&self) -> Type<'static> {
    Type {
      cow: Cow::Owned(str::to_owned(self.cow.borrow())),
      owned: self.owned.clone(), // always cloned, as requested
    }
  }
  /// Copy the structure and reference the original values.
  /// This is always a deep copy of the structure.
  pub fn to_borrowed(&self) -> Type {
    Type {
      cow: Cow::Borrowed(self.cow.borrow()),
      owned: self.owned.clone(), // always cloned, as requested
    }
  }
}

但实际上每个函数只调用派生出的特质的函数。

如果派生不起作用，可以手动实现并派生到使用它的类型。

泛型

派生宏支持所有类型的泛型：生命周期、类型、常量。前两种带有界限，次数不限。

引用

默认情况下不支持引用，因为它们不能转换为拥有类型。

但可以指定哪些生命周期仅用于引用，然后这些引用将被始终复制（引用），因此生命周期不会改变。

请注意，不仅包含引用的类型需要标记，还包含该类型的类型也需要标记。

示例

#[derive(IntoOwned, ToBorrowed, ToOwned)]
#[ownable(reference = "'b")]
pub struct Inner<'a, 'b> {
  cow: Cow<'a, str>,
  referenced: &'b str,
}

// Also types, containing types with references, must be marked.
#[derive(IntoOwned, ToBorrowed, ToOwned)]
#[ownable(reference = "'b")]
pub struct Outer<'a, 'b> {
  inner: Inner<'a, 'b>,
}

将派生具有这些签名的函数

impl<'b> Inner<'_, 'b> {
    pub fn into_owned(self) -> Inner<'static, 'b> {
        // Call the trait, which is also derived
    }
    pub fn to_owned(&self) -> Inner<'static, 'b> {
        // Call the trait, which is also derived
    }
    pub fn to_borrowed(&self) -> Inner<'_, 'b> {
        // Call the trait, which is also derived
    }
}

// The `Outer` will look similar.

可能的错误

如果发生以下错误，则某个字段缺少特质。

error[E0277]: the trait bound `String: IntoOwned` is not satisfied

有时可以通过将 #[ownable)] 作为示例中的示例添加到字段中来修复，否则 AsCopy/AsClone 有助于解决这个问题。

作为最后的手段，可以手动编写周围结构的 impl。

属性

clone

使用 #[ownable(clone)] 和 #[ownable(clone = false|true)]，可以表示这个枚举|结构体/变体/字段应该始终被克隆。它可以被覆盖（即在上层设置为 true，然后在不需要克隆的字段设置为 false）。

例如，请参见上方的示例。

函数

在顶层（枚举/结构体）使用 #[ownable(function = false)] 时，上述函数未实现，只有特型。

参考

使用 #[ownable(reference = "..")] 可以提供一个或多个逗号分隔的生命周期，用于引用，请参见上方的引用。

#[derive(IntoOwned, ToBorrowed, ToOwned)]
pub struct Type<'a> {
  cow: Cow<'a, str>,
  nested: Option<Box<Type<'a>>>,
  map: HashMap<AsClone<String>, Cow<'a, str>>,
  #[ownable(clone)] owned: String, // always clone this field
  number: usize, // many copy types have a trait impl, and thus can be used without the `#[ownable(clone)]`
}

[dependencies]
ownable = "0.5"

[dependencies]
ownable = { version = "0.5", default-features = false }