Performance 除锈牛散列集

想要存储大量字节数组，并希望通过

AHashMap

实现这一点，并使用Cow从中借用，仅在需要时写入，这也会导致重复数据消除。然而，到目前为止，我的尝试都是徒劳的：

#！[特征（散列设置项）]
使用std:：borrow:：{borrow，Cow，toowed}；
使用std:：hash:：hash；
使用ahash：：AHashSet；
#[导出（调试）]
结构密文，
密码：Vec{
密码_id:Cow>，
}
fn main（）{
让mut string_table:AHashSet=vec[
“你好，世界！”。作为字节（）到向量（），
“atbash”。作为字节（）到向量（），
“caesar_decrypt.”作为字节（）到向量（），
“5”。作为字节（）到向量（），
]
.into_iter（）
.收集（）；
让mut-ciphertexts:Vec=Vec[
密文{
密文：Cow:：借用(
串表
.get（&“Hello World！”.as_bytes（）.to_vec（））
.unwrap（），
),
密码：vec！[密码]{
cipher_id:Cow:：借用（string_table.get（&“atbash.as_bytes（）.to_vec（））.unwrap（）），
关键字：vec！[]，
}],
},
密文{
密文：Cow:：借用(
串表
.get（&“Hello World！”.as_bytes（）.to_vec（））
.unwrap（），
),
密码：vec！[密码]{
密码id:Cow:：借用(
串表
.get（&“caesar_decrypt”.as_bytes（）.to_vec（））
.unwrap（），
),
钥匙：vec！[Cow:：借用(
string_table.get（&“5.as_bytes（）.to_vec（））.unwrap（），
)],
}],
},
];
字符串_table.insert（“TEST”.as_bytes（）。to_vec（））；
字符串_table.insert（“TEST2.as_bytes（）.to_vec（））；
密文[0]。密文=Cow:：借用(
&string_table.get_或_insert_owned（&“再见残酷世界…”作为_bytes（）.to_vec（）），
);
}

两个测试行以及密文[0]行错误如下

error[E0502]：无法将'string_table'作为可变项借用，因为它也是作为不可变项借用的
-->src/main.rs:61:5
|
33 |字符串|表
|------此处发生不可变借用
...
61 | string_table.insert（“TEST”.as_bytes（）。to_vec（））；
|^^^^^^^^^^^^^^^^此处发生可变借用
...
64 |密文[0]。密文=Cow:：借用(
|--------此处稍后使用的不可变借用

---

我的目标是让所有字节数组只作为引用，然后克隆，添加到字符串表中，并在我更改它时引用。这些数据将以自定义二进制格式存储，这是编写序列化程序和反序列化程序的过程的开始。希望这一切都有意义！

在

密文

包含对它的引用。这只是Rust的核心不变量之一。因此，您不能使用

Cow

。其典型方法通常是：

使用索引/键引用另一个结构，不幸的是，在这个场景中，我看不到一个很好的方法

使用s以便密文和表共享字节的所有权。这确实意味着密文可以独立存在，但在明智地使用

get\u或\u insert

之前，您始终可以使用表作为代理来重复元素

#![feature(hash_set_entry)]

use std::rc::Rc;
use ahash::AHashSet;

#[derive(Debug)]
struct CipherText {
    ciphertext: Rc<Vec<u8>>,
    ciphers: Vec<Cipher>,
}

#[derive(Debug)]
struct Cipher {
    cipher_id: Rc<Vec<u8>>,
    keys: Vec<Rc<Vec<u8>>>,
}

fn main() {
    let mut string_table: AHashSet<Rc<Vec<u8>>> = vec![
        Rc::new("Hello World!".as_bytes().to_vec()),
        Rc::new("atbash".as_bytes().to_vec()),
        Rc::new("caesar_decrypt".as_bytes().to_vec()),
        Rc::new("5".as_bytes().to_vec()),
    ]
    .into_iter()
    .collect();

    let mut ciphertexts: Vec<CipherText> = vec![
        CipherText {
            ciphertext: string_table
                .get_or_insert(Rc::new("Hello World!".as_bytes().to_vec()))
                .clone(),
            ciphers: vec![Cipher {
                cipher_id: string_table
                    .get_or_insert(Rc::new("atbash".as_bytes().to_vec()))
                    .clone(),
                keys: vec![],
            }],
        },
        CipherText {
            ciphertext: string_table
                .get_or_insert(Rc::new("Hello World!".as_bytes().to_vec()))
                .clone(),
            ciphers: vec![Cipher {
                cipher_id: string_table
                    .get_or_insert(Rc::new("caesar_decrypt".as_bytes().to_vec()))
                    .clone(),
                keys: vec![string_table
                    .get_or_insert(Rc::new("5".as_bytes().to_vec()))
                    .clone()],
            }],
        },
    ];

    string_table.insert(Rc::new("TEST".as_bytes().to_vec()));
    string_table.insert(Rc::new("TEST2".as_bytes().to_vec()));

    ciphertexts[0].ciphertext = string_table
        .get_or_insert(Rc::new("Goodbye Cruel World...".as_bytes().to_vec()))
        .clone();
}

#！[功能（散列设置项）]
使用std:：rc:：rc；
使用ahash：：AHashSet；
#[导出（调试）]
结构密文{
密文：Rc，
密码：Vec，
}
#[导出（调试）]
结构密码{
密码id:Rc，
关键词：Vec，
}
fn main（）{
让mut string_table:AHashSet=vec[
Rc:：new（“Hello World！”。作为字节（）到向量（）），
Rc:：new（“atbash”.as_bytes（）.to_vec（）），
Rc:：new（“caesar_decrypt.”as_bytes（）to_vec（）），
Rc:：new（“5”。作为字节（）到向量（）），
]
.into_iter（）
.收集（）；
让mut-ciphertexts:Vec=Vec[
密文{
密文：字符串表
.get_或_insert（Rc:：new（“Hello World！”。作为_bytes（）到_vec（））
.clone（），
密码：vec！[密码]{
密码\u id:string\u表
.get_或_insert（Rc:：new（“atbash”）.as_bytes（）to_vec（））
.clone（），
关键字：vec！[]，
}],
},
密文{
密文：字符串表
.get_或_insert（Rc:：new（“Hello World！”。作为_bytes（）到_vec（））
.clone（），
密码：vec！[密码]{
密码\u id:string\u表
.get_或_insert（Rc:：new（“caesar_decrypt”）.as_bytes（）to_vec（））
.clone（），
键：vec！[string\u table
.get_或_insert（Rc:：new（“5”）.as_bytes（）to_vec（））
.clone（），
}],
},
];
string_table.insert（Rc:：new（“TEST”）。作为_bytes（）到_vec（））；
string_table.insert（Rc:：new（“TEST2.as_bytes（）.to_vec（））；
密文[0]。密文=字符串\u表
.get_或_insert（Rc:：new（“再见残酷的世界…”。作为_bytes（）。to_vec（）））
.clone（）；
}

这将与

Cow

具有相同的效果，

Rc

s拥有的元素是不可变的，因此必须创建一个新元素才能进行更改

---

什么不起作用？你有错误或者输出不是你期望的吗？@PeterHall编辑它只需移动两个

string\u表。在
let mut ciphertexts..
ciphertexts
从
string\u表
借用数据，你试图在
cipherte>时变异
string\u表
xts
仍在作用域中。@PeterHall字符串表在那里，可以更有效地表示字符串的复制时间。我希望密文vec包含对该字符串表的引用。当我