问题[rust](coding)

use std::marker::PhantomData;

trait SceneType {}

struct Scene<SceneType: ?Sized> {
    _phantom: PhantomData<SceneType>
}

pub enum SceneOne {}
impl SceneType for SceneOne {}

impl<SceneOne> Scene<SceneOne> {
    pub fn new() -> Self {
        Self {
            _phantom: Default::default()
        }
    }
}

fn main() {
    let scene = Scene::<SceneOne>::new();
    //works fine
    
    //1 let boxed_scene: Box<Scene<dyn SceneType>> = Box::new(Scene::<SceneOne>::new()); 
    // expected `Scene<dyn SceneType>`, found `Scene<SceneOne>` ... you could box the found value and coerce it to the trait object `Box<dyn SceneType>
    
    //2 let boxed_scene: Box<Scene<dyn SceneType>> = Box::new(scene) as Box<Scene<dyn SceneType>>; 
    // as` expression can only be used to convert between primitive types or to coerce to a specific trait object
}

游乐场链接

所以我最终来到这里的原因是我想要一个通用的新功能SceneType，并且具有可以在任何场景上运行的通用功能

impl<T: SceneType> Scene<T> {
    ...

我的问题是，由于列出的错误消息，我无法将这些类型装箱以将它们存储在向量中。2 的错误是有道理的，但据我所知，我试图将其强制转换为特定的特征类型。

?在这段代码中，在调用后添加运算符和不添加运算符有什么区别read_to_string()？为什么两者都有效=如果此调用失败会发生什么？

fn chaining() -> Result<String, std::io::Error> {
    let mut username = String::new();
    File::open("fake.txt")?.read_to_string(&mut username)?; // <- removing ? here also works
    Ok(username)
}

我有一个 4 X u32 类型的数组。我想要一个对数组的引用（指针），而不是切片（指针 + 长度）。下面的代码片段为切片和引用打印 16，这表明两种形式的初始化都返回一个切片。

是否存在一些语法可以返回对非切片数组的引用？

use std::mem;

fn main() {
    let array: [u32; 4] = [1, 2, 3, 4];
    let slice: &[u32] = &array[..];
    let reference: &[u32; 4] = &array;
    println!("size(slice)     = {:?}", mem::size_of_val(slice)); // Prints: 16
    println!("size(reference) = {:?}", mem::size_of_val(reference)); // Prints: 16
}

锈迹游乐场

我正在尝试创建一个 Rust 程序，其中包含一个人物向量，以及另一个引用上述人物的事件向量（例如出生和死亡）。

但是，我无法找到一种方法来同时 1）将人的所有权转移到一个向量，以及 2）将引用保存在另一个向量中。

下面我粘贴了一个高度简化的应用程序版本，其中包含我当前的问题和一些解决方法。

struct Person {
    name: String
}

enum Event<'a> {
    PersonBorn(i32, &'a Person),
    PersonDied(i32, &'a Person),
}

struct Universe<'a> {
    people: Vec<Person>,
    events: Vec<Event<'a>>
}

fn main() {
    let mut data = Universe {
        people: Vec::new(),
        events: Vec::new()
    };

    let names = ["John", "Joe"];

    for name in names {
        let year = 1993;

        let person = Person {
            name: String::from(name)
        };
        data.people.push(person);

        // Attempt 1: Doesn't work because "person" was moved on "push' on line 29
        data.events.push(Event::PersonBorn(year, &person));

        // Attempt 2: Doesn't work because it's an immutable borrow of "data",
        // while doing a mutable borrow on line 29
        // data.events.push(Event::PersonBorn(year, &data.people.last().unwrap()));

    }

    // Attempt 3: In this simplified example, this works, but in my real
    // program I would not know the year anymore at this point
    //for person in data.people.iter() {
    //    data.events.push(Event::PersonBorn(year, person));
    //}

    for event in data.events {
        match event {
            Event::PersonBorn(year, person) => println!("{} was born in {}", person.name, year),
            Event::PersonDied(year, person) => println!("{} died in {}", person.name, year),
        }
        
    }

}

现在，我明白了为什么尝试 1（移动后借用）和尝试 2（for 循环中的可变和不可变引用）会失败。

但是，我能想到的唯一解决方法是尝试 3，但这在实际应用中是不可行的。

还有其他我没见过的方法可以做到这一点吗？

我正在尝试将 ORM 添加到现有结构中：

#[derive(Debug, Queryable, Selectable)]
#[diesel(table_name = crate::schema::tokens)]
pub struct Token {
    pub public_key: String,
    pub name: Option<String>,

cannot find type `name` in module `crate::schema::tokens`
not found in `crate::schema::tokens`

在结构体的字段上方添加哪些宏来忽略数据库操作？

当我使用 serde 构建我的驱动程序时（default-features = false按照文档）我得到：

error[E0152]: duplicate lang item in crate `std` (which `serde` depends on): `panic_impl`
  |
  = note: the lang item is first defined in crate `wdk_panic` (which `drv` depends on)
  = note: first definition in `wdk_panic` loaded from \\?\C:\Users\user\git\drv\driver\target\debug\deps\libwdk_panic-4cc9693e0f1d2bfe.rmeta
  = note: second definition in `std` loaded from \\?\C:\Users\user\.rustup\toolchains\nightly-2024-10-26-x86_64-pc-windows-msvc\lib\rustlib\x86_64-pc-windows-msvc\lib\libstd-60ed92c773e701f8.rlib

我按照以下说明在我的驱动程序项目中使用 serde

[package]
name = "drv"
version = "0.0.2"
edition = "2021"
build = "build.rs"

[package.metadata.wdk.driver-model]
driver-type = "WDM"

[lib]
crate-type = ["cdylib"]
test = false

[features]
default = []
nightly = ["wdk/nightly", "wdk-sys/nightly"]

[dependencies]
wdk = "0.3.0"
wdk-alloc = "0.3.0"
wdk-sys = "0.3.0"
wdk-build = "0.3.0"
wdk-panic = "0.3.0"
shared_no_std = { path = "../shared_no_std" }
serde = { version = "1.0", default-features = false, features = ["derive", "alloc"] }
serde_json = {version = "1.0.132", default-features = false, features = ["alloc"] }

[profile.dev]
panic = "abort"
lto = true

[profile.release]
panic = "abort"
lto = true

[build-dependencies]
wdk-build = "0.3.0"

在我的lib.rs：

#![no_std]
extern crate alloc;

#[cfg(not(test))]
extern crate wdk_panic;
use wdk_panic as _;

use core::core_callback_notify_ps;
use ::core::ptr::null_mut;
use wdk::{nt_success, println};
#[cfg(not(test))]
use wdk_alloc::WdkAllocator;

mod ffi;
mod utils;
mod device_comms;
mod core;

#[cfg(not(test))]
#[global_allocator]
static GLOBAL_ALLOCATOR: WdkAllocator = WdkAllocator;

我认为我已经设置好了一切，可以no_std从 serde 中使用 - 我还检查了删除本地 crate 的依赖项shared_no_std，但仍然出现相同的错误。它似乎是通过 serde 从 std 重新实现 panic_impl？

我还将以下内容添加到我的shared_no_std（按照一个堆栈溢出答案，但这没有任何改变，在此之前我只是声明它是no_std）：

#![cfg_attr(not(feature = "std"), no_std)]

输出cargo tree -i serde -e features

PS C:\Users\User\git\drv\driver> cargo tree -i serde -e features
serde v1.0.215
└── serde_json v1.0.132
    └── serde_json feature "alloc"
        ├── drv v0.0.2 (C:\Users\User\git\drv\driver)
        │   └── drv feature "default" (command-line)
        └── shared_no_std v0.0.2 (C:\Users\User\git\drv\shared_no_std)
            └── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
├── serde feature "alloc"
│   ├── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
│   └── shared_no_std v0.0.2 (C:\Users\User\git\drv\shared_no_std) (*)
│   └── serde_json feature "alloc" (*)
├── serde feature "derive"
│   ├── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
│   └── shared_no_std v0.0.2 (C:\Users\User\git\drv\shared_no_std) (*)
└── serde feature "serde_derive"
    └── serde feature "derive" (*)

serde v1.0.215
├── semver v1.0.23
│   ├── semver feature "default"
│   │   └── cargo_metadata v0.18.1
│   │       └── cargo_metadata feature "default"
│   │           └── wdk-build v0.3.0
│   │               └── wdk-build feature "default"
│   │                   └── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
│   │                   [build-dependencies]
│   │                   ├── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
│   │                   ├── wdk v0.3.0
│   │                   │   ├── wdk feature "alloc"
│   │                   │   │   └── wdk feature "default"
│   │                   │   │       └── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
│   │                   │   └── wdk feature "default" (*)
│   │                   ├── wdk-alloc v0.3.0
│   │                   │   └── wdk-alloc feature "default"
│   │                   │       └── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
│   │                   └── wdk-sys v0.3.0
│   │                       └── wdk-sys feature "default"
│   │                           ├── drv v0.0.2 (C:\Users\User\git\drv\driver) (*)
│   │                           ├── wdk v0.3.0 (*)
│   │                           └── wdk-alloc v0.3.0 (*)
│   │           [build-dependencies]
│   │           └── wdk-sys v0.3.0 (*)
│   ├── semver feature "serde"
│   │   └── cargo_metadata v0.18.1 (*)
│   └── semver feature "std"
│       └── semver feature "default" (*)
└── serde_json v1.0.132
    ├── serde_json feature "default"
    │   ├── cargo_metadata v0.18.1 (*)
    │   └── wdk-build v0.3.0 (*)
    │   [build-dependencies]
    │   └── wdk-sys v0.3.0 (*)
    ├── serde_json feature "std"
    │   └── serde_json feature "default" (*)
    └── serde_json feature "unbounded_depth"
        └── cargo_metadata v0.18.1 (*)
├── serde feature "default"
│   ├── camino v1.1.9
│   │   ├── camino feature "default"
│   │   │   ├── cargo_metadata v0.18.1 (*)
│   │   │   └── wdk-build v0.3.0 (*)
│   │   ├── camino feature "serde"
│   │   │   └── camino feature "serde1"
│   │   │       └── cargo_metadata v0.18.1 (*)
│   │   └── camino feature "serde1" (*)
│   ├── cargo-platform v0.1.8
│   │   └── cargo-platform feature "default"
│   │       └── cargo_metadata v0.18.1 (*)
│   ├── cargo_metadata v0.18.1 (*)
│   └── wdk-build v0.3.0 (*)
├── serde feature "derive"
│   ├── camino v1.1.9 (*)
│   ├── cargo_metadata v0.18.1 (*)
│   └── wdk-build v0.3.0 (*)
├── serde feature "serde_derive"
│   └── serde feature "derive" (*)
└── serde feature "std"
    ├── serde feature "default" (*)
    └── serde_json feature "std" (*)

如何在 Rust 中将多个通用错误类型包装在自定义 Error 枚举周围。这很简单，我只想让它工作。

enum Error<SPIE, PINE> {
  SpiError(SPIE),
  PinError(PINE),
  // other custom errors
}
impl<SPIE,PINE> From<SPIE> for Error<SPIE,PINE> {
  fn from(value: SPIE) -> Self {
      Self::SpiError(value)
  }
}
impl<SPIE,PINE> From<PINE> for Error<SPIE,PINE> {
  fn from(value: PINE) -> Self {
      Self::PinError(value)
  }
}

相反，编译器抱怨说：

conflicting implementations of trait `From<_>` for type `Error<_, _>`

我理解这一点，但也许我可以以某种方式区分这两种类型……

常规UUIDshort-uuid-rs可以缩短。例如，当我想转换 UUID 以适合 Code39 条形码时，这将起作用：

let uuid_str = "420e04de-4f06-4e3b-8718-9f6ede92ea9e";
let custom_alphabet = "0123456789ABCDEFGHJKLMNPQRSTUVWXYZ-.$/+%";
let translator = CustomTranslator::new(custom_alphabet).unwrap();
let uuid = uuid::Uuid::from_str(uuid_str).unwrap();
let short = ShortUuidCustom::from_uuid(&uuid, &translator);
println!("{}", short.to_string());  // prints "0CK3Z2YL23B7.Q1FR8N65R7X6"

但是一旦使用条形码扫描仪扫描短代码，它就需要再次编码常规 UUID。

如何将其转换回来？

我尝试过MindSwipe的解决方案：

let custom_alphabet = "0123456789ABCDEFGHJKLMNPQRSTUVWXYZ-.$/+%";
let translator = CustomTranslator::new(custom_alphabet).unwrap();
// there
let orig_uuid_str = "420e04de-4f06-4e3b-8718-9f6ede92ea9e";
let short = ShortUuidCustom::from_uuid_str(&orig_uuid_str, &translator).unwrap();
let short_uuid_str = &short.to_string();
// and back again
let short = match ShortUuidCustom::parse_str(short_uuid_str, &translator) {
  Ok(s) => s,
  Err(e) => panic!("{:?}", e),
};
let new_uuid_str = &short.to_uuid(&translator).unwrap().to_string();
assert_eq!(orig_uuid_str, new_uuid_str);

不幸的是，parse_str()出现了InvalidShortUuid错误。我想我肯定做错了什么？

当某些控制路径会丢弃某个值时，该点之后的所有控制路径都无法再次访问该变量。在下面的示例中，在 if 语句之后访问保护将是一个错误。尽管如此，Rust 实际上并没有丢弃该值，直到它超出范围。为什么不呢？我想不出任何让对象保持活动的合理理由，而且它似乎很可能导致死锁（这就是我遇到这种行为的原因）。

use scopeguard; // 1.2.0

fn func(guard: impl std::fmt::Debug) {
    if false {
        drop(guard);
    }
    println!("guard is not yet dropped")
}

fn main() {
    let guard = scopeguard::guard((), |_| println!("value dropped"));
    func(guard);
}

相关问题“为什么这个值在最后一次使用后不会被删除？”有所不同，因为该值在最后一次使用后仍然可以命名。在这个问题中，该值在 if 语句之后是不可命名的（接受的答案中显示了例外情况）。

我有一个包含大量 MP3 文件的文件夹，我想创建一个 Rust 程序以随机​​顺序播放这些文件。（注意：我有两层文件夹。）

我希望我的程序是跨平台的（它必须在 Windows 和 Linux 上运行）并且可移植（它不能依赖于已安装的程序，如 VLC、Windows Media Player 等）。

我用这个库编写了这个程序rodio：

use std::io::Cursor;
use rodio::{Decoder, OutputStream, source::Source};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let (_stream, stream_handle) = OutputStream::try_default().unwrap();
    let sound_data = include_bytes!("song.mp3");
    let source = Decoder::new_mp3(Cursor::new(&sound_data[..])).unwrap();
    stream_handle.play_raw(source.convert_samples())?;
    std::thread::sleep(std::time::Duration::from_secs(240));
    Ok(())
}

但该程序只能播放一个文件。

我需要一个HashMap以文件名为键、以代表文件内容的切片为值的东西。