此外，这个crate允许将每个枚举变体的相关数据提取到单独的结构体中，这可以在设计抽象语法树时使代码更加紧凑。有关详细信息，请参阅extract宏文档。

也可以将这两个宏按正确顺序组合使用：首先是 extract，然后是 enpow。组合这两个宏可以避免为 Ref 或 Mut 结构体变体生成单独的结构体，如以下用例演示中进一步解释的那样。不过，这两个宏也可以独立使用。

安装

⚠️ 支持的最小 Rust 工具链版本是 Rust 1.58.0

将以下内容添加到您的 Cargo.toml 中，以便将 enpow 作为依赖项添加到您的项目中。

[dependencies]
enpow = "~2.0.2"

或者，在您的 crate 根目录内运行以下命令。

cargo add enpow

快速入门

Enpow

要为枚举生成所有可用方法，导入 enpow 宏，并在枚举定义之前添加 #[enpow(All)]。您还可以选择性地生成某些方法。有关更多信息，请参阅以下用例演示或 enpow 宏的文档。

use enpow::enpow;

#[enpow(All)]
pub enum IpAddress {
    None,
    V4(u8, u8, u8, u8),
    V6(String),
    Multi {
        v4: (u8, u8, u8, u8),
        v6: String,
    },
}

一些 生成的函数如下

• fn v4(self) -> Option<(u8, u8, u8, u8)>
• fn is_none(&self) -> bool
• fn unwrap_v6(self) ->String
• fn expect_multi(self, msg: &str) ->IpAddressMulti
• ...

除了这些方法外，还需要生成以下结构体

pub struct IpAddressMulti {
    pub v4: (u8, u8, u8, u8),
    pub v6: String,
}

Extract

要提取枚举的所有变体到单独的类型中，导入 extract 宏，并在枚举定义之前添加 #[extract(All)]。您还可以选择性地提取某些变体。有关更多信息，请参阅以下用例演示或 extract 宏的文档。

use enpow::extract;

#[extract(All)]
pub enum IpAddress {
    None,
    V4(u8, u8, u8, u8),
    V6(String),
    Multi {
        v4: (u8, u8, u8, u8),
        v6: String,
    },
}

这将生成以下数据类型

pub enum IpAddress {
    None(IpAddressNone),
    V4(IpAddressV4),
    V6(IpAddressV6),
    Multi(IpAddressMulti),
}

pub struct IpAddressNone;

pub struct IpAddressV4(pub u8, pub u8, pub u8, pub u8);

pub struct IpAddressV6(pub String);

pub struct IpAddressMulti {
    pub v4: (u8, u8, u8, u8),
    pub v6: String,
}

用例

以下代码描述了一个简单的支持不同日志级别的日志系统。然后我们创建一个示例日志并打印其中的所有错误。

/// A log entry
#[derive(Clone)]
pub enum LogEntry<C: ToString + Clone> {
    /// A simple note without context
    Note(
        /// Note's message
        String
    ),
    /// A warning with a given context
    Warning(
        /// Warning's message
        String,
        /// Context of the warning
        C
    ),
    /// An error message with error code and context
    Error {
        /// Error message
        message: String,
        /// Context of the error
        context: C,
        /// Error code
        code: i16,
    },
}

/// Application log for a certain context type
pub struct Log<C: ToString + Clone> {
    /// Log entries
    entries: Vec<LogEntry<C>>,
}

impl<C: ToString + Clone> Log<C> {
    /// Collects all entries of type `LogEntry::Error` from the log
    pub fn get_errors(&self) -> Vec<LogEntry<C>> {
        self.entries.iter()
            .filter(|entry| match entry {
                LogEntry::Error { .. } => true,
                _ => false,
            })
            .cloned()
            .collect()
    }
}

/// Line number in source
type Line = usize;

// Create a sample log
let log = Log { entries: vec![
    LogEntry::Note("All fine 😊".into()),
    LogEntry::Warning("There might be an issue here 🤔".into(), 4),
    LogEntry::Error {
        message: "There _was_ an issue 😖".into(),
        context: 4,
        code: -1,
    },
    LogEntry::Error {
        message: "Follow up".into(),
        context: 12,
        code: -7,
    },
] };

// Get and print all errors
let errors = log.get_errors();
if !errors.is_empty() {
    eprintln!("Failed for the following reasons:");

    for error in errors {
        match error {
            LogEntry::Error { message, context: line, code } => {
                eprintln!("Error {code} at {line}: {message}");
            }
            _ => panic!("Expected to find a LogEntry::Error"),
        }
    }
}

此代码可以工作，但是每次都需要对每个日志条目的具体变体进行模式匹配，这略显冗长。

使用 enpow

这时，enpow 宏就派上用场了。它可以生成一些辅助方法，可以使我们的代码更加简洁。我们特别使用了 is_<variant>() （关键字 IsVar）和 unwrap_<variant>() （关键字 UnwrapVar）方法。

use enpow::enpow; // ℹ️

/// A log entry
#[enpow(IsVar, UnwrapVar)] // ℹ️
#[derive(Clone)]
pub enum LogEntry<C: ToString + Clone> {
    /// A simple note without context
    Note(
        /// Note's message
        String
    ),
    /// A warning with a given context
    Warning(
        /// Warning's message
        String,
        /// Context of the warning
        C
    ),
    /// An error message with error code and context
    Error {
        /// Error message
        message: String,
        /// Context of the error
        context: C,
        /// Error code
        code: i16,
    },
}

/// Application log for a certain context type
pub struct Log<C: ToString + Clone> {
    /// Log entries
    entries: Vec<LogEntry<C>>,
}

impl<C: ToString + Clone> Log<C> {
    /// Collects all entries of type `LogEntry::Error` from the log
    pub fn get_errors(&self) -> Vec<LogEntry<C>> {
        self.entries.iter()
            .filter(|entry| entry.is_error()) // ℹ️
            .cloned()
            .collect()
    }
}

/// Line number in source
type Line = usize;

// Create a sample log
let log = Log { entries: vec![
    LogEntry::Note("All fine 😊".into()),
    LogEntry::Warning("There might be an issue here 🤔".into(), 4),
    LogEntry::Error {
        message: "There _was_ an issue 😖".into(),
        context: 4,
        code: -1,
    },
    LogEntry::Error {
        message: "Follow up".into(),
        context: 12,
        code: -7,
    },
] };

// Get and print all errors
let errors = log.get_errors();
if !errors.is_empty() {
    eprintln!("Failed for the following reasons:");

    for error in errors {
        let error = error.unwrap_error();  // ℹ️
        eprintln!("Error {} at {}: {}", error.code, error.context, error.message);
    }
}