5. 指定自定义验证器（可选）

您可以指定自定义验证器。在转换为外部类型时，会验证内部类型的值。通过自定义验证器，您可以限制内部值。

要使用自定义验证器，请指定以下属性

• validator
  • 验证器函数。它应具有以下类型之一：Inner -> Result<Inner, Error>。
    • 对于有大小类型，Inner -> Result<Inner, Error>。验证器可以修改给定的值并返回修改后的值。
    • 对于无大小类型，&Inner -> Result<&Inner, Error>。
• error_type
  • 验证错误类型。通过 validator 指定的验证器应使用此类型作为错误。
  • 这不能是泛型，并且不能使用外部类型的任何类型参数。
• error_msg（可选）
  • 在验证失败时引发恐慌的错误消息。当将无效值传递给 Outer::from_inner（而不是 Outer::try_from_inner）时，将使用此值。
  • 内部，当 error_msg 缺失时，将使用 unwrap() 引发恐慌，而当 error_msg 已指定时，将使用 expect(error_msg)。

以下示例取自opaque_typedef_tests/src/even32.rs和opaque_typedef_tests/tests/even32.rs。

/// Even `i32`.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, OpaqueTypedef)]
#[opaque_typedef(derive(Binary, Deref, Display, FromInner, PartialEq(Inner, InnerRev),
                        PartialOrd(Inner, InnerRev), LowerHex, Octal, UpperHex))]
#[opaque_typedef(validation(validator = "validate_even32", error_type = "OddError",
                            error_msg = "Failed to create `Even32`"))]
pub struct Even32(i32);

impl Even32 {
    /// Returns the inner `i32` even value.
    pub fn to_i32(&self) -> i32 {
        self.0
    }
}

/// A type of an error indicating the integer is an odd number, not even.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct OddError;

fn validate_even32(v: i32) -> Result<i32, OddError> {
    if v % 2 == 0 {
        Ok(v)
    } else {
        Err(OddError)
    }
}

#[cfg(test)]
mod tests {
    #[test]
    fn ok() {
        let v = Even32::from(42);
        assert_eq!(v.to_i32(), 42);
    }

    #[test]
    #[should_panic]
    fn from_odd() {
        // Panics with message "Failed to create `Even32`: OddError".
        let _ = Even32::from(3);
    }
}

6. 指定自定义比较器（可选）

您可以使用自定义实现来为PartialEq和PartialOrd。

要使用自定义比较器，请指定以下属性：

• partial_eq
  • 部分相等函数。这应该具有以下类型的函数：&Inner -> &Inner -> bool。
• partial_ord
  • 部分排序函数。这应该具有以下类型的函数：&Inner -> &Inner -> Option<::std::cmp::Ordering>。
• ord
  • 完全排序函数。这应该具有以下类型的函数：&Inner -> &Inner -> ::std::cmp::Ordering。
  • #[derive(Ord)]不使用PartialOrd::partial_cmp实现，因此可能会错误地不一致。请记住保持它们（包括PartialEq::eq）一致性。

以下示例取自opaque_typedef_tests/src/reverse_order.rs和opaque_typedef_tests/tests/reverse_order.rs。

/// A wrapper type with reverse order.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Ord, Hash, OpaqueTypedef)]
#[opaque_typedef(derive(AsciiExt, AsMut(Deref), AsRef(Deref), Binary, Deref, DerefMut, Display,
                        FromInner, LowerHex, Octal, PartialOrdSelf, UpperHex))]
#[opaque_typedef(cmp(partial_ord = "(|a, b| PartialOrd::partial_cmp(a, b).map(|o| o.reverse()))",
                     ord = "(|a, b| Ord::cmp(a, b).reverse())"))]
#[opaque_typedef(allow_mut_ref)]
pub struct ReverseOrderSized<T>(pub T);


#[test]
fn reverse_i32() {
    use std::cmp::Ordering;
    assert_eq!(ReverseOrderSized(3i32).partial_cmp(&ReverseOrderSized(2i32)), Some(Ordering::Less));
    assert!(ReverseOrderSized(3i32) < ReverseOrderSized(2i32));
    assert_eq!(ReverseOrderSized(3i32).cmp(&ReverseOrderSized(2i32)), Ordering::Less);
    assert_eq!(ReverseOrderSized(3i32).cmp(&ReverseOrderSized(3i32)), Ordering::Equal);
    assert_eq!(ReverseOrderSized(3i32).cmp(&ReverseOrderSized(4i32)), Ordering::Greater);
}

特性

定义基本构造和转换

对于有尺寸类型

#[derive(OpaqueTypedef)]实现了opaque_typedef::OpaqueTypedef特质，并且它有一些基本且有用的方法。

有关详细信息，请参阅https://docs.rs/opaque_typedef/*/opaque_typedef/trait.OpaqueTypedef.html。

对于无尺寸类型

#[derive(OpaqueTypedefUnsized)]实现了opaque_typedef::OpaqueTypedefUnsized特质，并且它有一些基本且有用的方法。特别是OpaqueTypedefUnsized::from_inner()将会非常实用。

有关详细信息，请参阅https://docs.rs/opaque_typedef/*/opaque_typedef/trait.OpaqueTypedefUnsized.html。

自动为许多std特质生成

以下特质受支持。

请注意，某些特质（如DefaultRef）仅适用于有大小类型。

std::convert，类型转换

• 如{Mut,Ref}{Deref,Inner,Self}
  • AsMutDeref实现了AsMut<DerefTarget> for Outer。
  • AsMutInner实现了AsMut<Inner> for Outer。
  • AsMutSelf实现了AsMut<Outer> for Outer。
  • AsRefDeref实现了AsRef<DerefTarget> for Outer。
  • AsRefInner实现了AsRef<Inner> for Outer。
  • AsRefSelf实现了AsRef<Self> for Outer。
• Deref，DerefMut
  • Deref实现了std::ops::Deref for Outer。
  • DerefMut实现了std::ops::DerefMut for Outer。
• Into{Arc,Box,Inner,Rc}，FromInner
  • IntoArc实现了From<Outer> for Arc<Outer>（如果可能）或Into<Arc<Outer>> for Outer。
  • IntoBox 实现了 From<Outer> for Box<Outer>（如果可能）或 Into<Box<Outer>> for Outer。
  • IntoInner 实现了 From<Outer> for Inner。
  • IntoRc 实现了 From<Outer> for Rc<Outer>（如果可能）或 Into<Rc<Outer>> for Outer。
  • FromInner 实现了 From<Inner> for Outer。

std::fmt

• std::fmt::*
  • Binary 实现了 std::fmt::Binary for Outer。
  • Display 实现了 std::fmt::Display for Outer。
  • LowerExp 实现了 std::fmt::LowerExp for Outer。
  • LowerHex 实现了 std::fmt::LowerHex for Outer。
  • Octal 实现了 std::fmt::Octal for Outer。
  • Pointer 实现了 std::fmt::Pointer for Outer。
  • UpperExp 实现了 std::fmt::UpperExp for Outer。
  • UpperHex 实现了 std::fmt::UpperHex for Outer。

std::cmp

• Partial{Eq,Ord}{Inner,InnerCow,SelfCow}{,Rev}
  • PartialEqInner 实现了 PartialEq<Inner> for Outer 以及类似的功能。
  • PartialEqInnerRev 实现了 PartialEq<Outer> for Inner 以及类似的功能。
    • 这是 PartialEqInner 的逆操作（操作数顺序颠倒）版本。
  • PartialEqInnerCow 实现了 PartialEq<Cow<Inner>> for Outer 以及类似的功能。
  • PartialEqInnerCowRev 实现了 PartialEq<Outer> for Cow<Inner> 以及类似的接口。
    • 这是 PartialEqInnerCow 的反向版本（操作数顺序颠倒）。
  • PartialEqSelf 实现了 PartialEq<Outer> for Outer 以及类似的接口。
    • 这与 #[derive(PartialEq)] 非常相似，但它可以用于自定义比较。
  • PartialEqSelfCow 实现了 PartialEq<Cow<Outer>> for Outer 以及类似的接口。
  • PartialEqSelfCowRev 实现了 PartialEq<Outer> for Cow<Outer> 以及类似的接口。
    • 这是 PartialEqSelfCow 的反向版本（操作数顺序颠倒）。
  • PartialEqSelfCowRev 实现了 PartialEq<Outer> for Cow<Outer> 以及类似的接口。
  • PartialEqSelfCowRev 是 PartialEqSelfCow 的反向版本（操作数顺序颠倒）。
    • PartialEqSelfCowRev 实现了 PartialEq<Outer> for Cow<Outer> 以及类似的接口。
  • 这是 PartialEqSelfCowRev 的反向版本（操作数顺序颠倒）。
  • PartialEqSelfCowRev 实现了 PartialEq<Outer> for Cow<Outer> 以及类似的接口。
    • 这是 PartialEqSelfCowRev 的反向版本（操作数顺序颠倒）。
  • PartialEqSelfCowRev 实现了 PartialEq<Outer> for Cow<Outer> 以及类似的接口。
  • 这是 PartialEqSelfCowRev 的反向版本（操作数顺序颠倒）。
    • PartialEqSelfCowRev 实现了 PartialEq<Outer> for Cow<Outer> 以及类似的接口。
  • PartialOrdSelf 实现了 PartialOrd<Outer> for Outer 以及类似的功能。
    • 这与 #[derive(PartialOrd)] 非常相似，但在自定义比较时将非常有用。
  • PartialOrdSelfCow 实现了 PartialOrd<Cow<Outer>> for Outer 以及类似的功能。
  • PartialOrdSelfCowRev 实现了 PartialOrd<Outer> for Cow<Outer> 以及类似的功能。
    • 这是 PartialOrdSelfCow 的反向（操作数顺序颠倒）版本。
  • PartialOrdSelfCowAndInner 实现了 PartialOrd<Cow<Outer>> for Inner 以及类似的功能。
  • PartialOrdSelfCowAndInnerCow 实现了 PartialOrd<Inner> for Cow<Outer> 以及类似的功能。
    • 这是 PartialOrdSelfCowAndInner 的反向（操作数顺序颠倒）版本。
• Ord
  • Ord 实现了 std::cmp::Ord for Outer。
    • 这与 #[derive(Ord)] 非常相似，但在自定义比较时将非常有用。

std::ops

• 一元运算符
  • 取反{,Ref}
  • 非{,Ref}
• 二元运算符
  • {加,位与,位或,位异或,除,乘,取模,左移,右移,减}{,赋值}{,Ref}{Self,Inner,内反向}

其他

• AsciiExt 实现了 std::ascii::AsciiExt for Outer。
• DefaultRef 实现了 Default for &Outer。

待办事项

• 更多特质
  • 夜间仅有的特质（TryFrom，TryInto，...） (#6)
• 支持具有多个字段的数据类型 (#9)

许可证

根据您的选择，许可协议为以下之一

• Apache License，版本 2.0，(LICENSE-APACHE.txt 或 https://www.apache.org/licenses/LICENSE-2.0 )
• MIT 许可证 (LICENSE-MIT.txt 或 https://opensource.org/licenses/MIT )

。

贡献

除非您明确声明，否则根据Apache-2.0许可证定义，您有意提交以包含在该作品中的任何贡献，将双重许可如上所述，没有任何附加条款或条件。