static-atom

表示一组固定的字符串作为 Rust enum。有效地将传入的字符串转换为相应的 enum 情况。

基准测试

基准测试 将以下字符串之一解码为 Option<usize>

• "BTC-EUR" 产生 Some(1)
• "BTC-USDC" 产生 Some(2)
• "ETH-EUR" 产生 Some(3)
• "ETH-BTC" 产生 Some(4)
• 其他任何内容都产生 None

方法有

• match_keyword - 标准 Rust match 关键字。检查切片的长度，然后检查切片的指针与字符串字面量的比较，然后调用 memcmp。
• trie_generated_small - 一次消费一个或多个字节，以缩小剩余字符串的有效后缀。如果剩余字符串的选择足够不同，则消费 u16、u32 或 u64。
• trie_generated_big - 与 trie_generated_small 类似，但生成的代码对 24 个字符串进行测试，而不是 4 个。

有效 1

有效 2

有效 3

有效 4

无效，空内容

无效，第一个字符

无效，最后一个字符

无效，过长

无效，过短

示例生成的代码

#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub enum Small {
    _0, // "BTC-EUR"
    _1, // "BTC-USDC"
    _2, // "ETH-EUR"
    _3, // "ETH-BTC"
}

#[macro_export]
macro_rules! small {
("BTC-EUR") => { $crate::Small::_0 };
("BTC-USDC") => { $crate::Small::_1 };
("ETH-EUR") => { $crate::Small::_2 };
("ETH-BTC") => { $crate::Small::_3 };
}

impl FromStr for Small {
    type Err = ();

    #[allow(unused_variables)]
    fn from_str(s: &str) -> Result<Self, ()> {
        let s = s.as_bytes();
        match s.len() {
            7 => {
                if let Some(s) = s.expect(b"BTC-EUR") {
                    Ok(small!("BTC-EUR"))
                } else if let Some(s) = s.expect(b"ETH-") {
                    if let Some(s) = s.expect(b"BTC") {
                        Ok(small!("ETH-BTC"))
                    } else if let Some(s) = s.expect(b"EUR") {
                        Ok(small!("ETH-EUR"))
                    } else { Err(()) }
                } else { Err(()) }
            }
            8 => {
                if let Some(s) = s.expect(b"BTC-USDC") {
                    Ok(small!("BTC-USDC"))
                } else { Err(()) }
            }
            _ => Err(())
        }
    }
}

impl Small {
    pub fn as_str(&self) -> &'static str {
        match self {
            small!("BTC-EUR") => "BTC-EUR",
            small!("BTC-USDC") => "BTC-USDC",
            small!("ETH-EUR") => "ETH-EUR",
            small!("ETH-BTC") => "ETH-BTC",
        }
    }
}

impl From<Small> for usize {
    fn from(token: Small) -> Self {
        match token {
            small!("BTC-EUR") => 0,
            small!("BTC-USDC") => 1,
            small!("ETH-EUR") => 2,
            small!("ETH-BTC") => 3,
        }
    }
}

impl fmt::Debug for Small {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "small!({})", self.as_str())
    }
}

impl fmt::Display for Small {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str(self.as_str())
    }
}