kyleqian's questions

我有一个小游戏应用程序，使用特征对象来处理关键事件并修改应用程序状态：

pub trait GameScene {
    fn handle_key_events(&self, app: &mut TypingApp, key_event: KeyEvent) -> Result<()>;
}

pub struct StartupScene {}

impl GameScene for StartupScene {
    fn handle_key_events(&self, app: &mut TypingApp, key_event: KeyEvent) -> Result<()> {
        todo!()
    }
}

pub struct TypingApp {
    /// lots of other members here
    /// ......
    /// modify above members according to the user's input
    pub cur_scene: Box<dyn GameScene>
}

impl Default for TypingApp {
    fn default() -> Self {
        Self {
            cur_scene: Box::new(StartupScene{})
        }
    }
}

impl TypingApp {
    pub fn handle_key_events(&mut self, key_event: KeyEvent) -> Result<()> {
        self.cur_scene.handle_key_events(self, key_event)
    }
}

这无法编译，因为最后一个handle_key_events函数：

error[E0502]: cannot borrow `*self` as mutable because it is also borrowed as immutable
  --> src/app.rs:53:9
   |
53 |         self.cur_scene.handle_key_events(self, key_event)
   |         --------------^-----------------^^^^^^^^^^^^^^^^^
   |         |              |
   |         |              immutable borrow later used by call
   |         mutable borrow occurs here
   |         immutable borrow occurs here

我只想使用GameScene对象来修改的成员TypingApp，我该如何修复这个编译错误？谢谢！

在actix-web路由功能中，我发现从互斥锁保护对象获取独立数据后，互斥锁必须处于锁定状态才能使用这些数据。如果互斥体仅在获取数据时加锁，则使用数据时会出现编译错误。下面是可以直接编译的代码：

use std::collections::HashMap;
use std::fmt::Debug;
use std::sync::Mutex;
use async_trait::async_trait;
use actix_web::{web, App, HttpServer, HttpResponse, Result as ActixResult};

#[async_trait]
pub trait Reader: Send + Debug { }

#[derive(Clone, Debug)]
pub struct RemoteReader;

#[async_trait]
impl Reader for RemoteReader { }

#[derive(Default)]
pub struct DataReaders(HashMap<String, Box<dyn Reader>>);

impl DataReaders {
    pub fn get_readers(&self, ids: &str) -> ActixResult<Vec<&dyn Reader>> {
        let mut readers = Vec::new();
        for id in ids.split(',') {
            readers.push(self.0.get(id).unwrap().as_ref());
        }
        Ok(readers)
    }
}

async fn get(data: web::Data<Mutex<DataReaders>>) -> ActixResult<HttpResponse> {
    let mut readers = data.lock().unwrap().get_readers("1,2")?;
    if readers.is_empty() {
        return Ok(HttpResponse::NotFound().finish())
    }
    // Below will call multiple asynchronous functions, so I do not want to
    // hold the lock of DataReaders for a long time.
    readers.clear();
    Ok(HttpResponse::Ok().finish())
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    let mut readers = DataReaders{ 0: Default::default() };
    readers.0.insert("1".to_string(), Box::new(RemoteReader{}));
    readers.0.insert("2".to_string(), Box::new(RemoteReader{}));
    let counter = web::Data::new(Mutex::new(readers));

    HttpServer::new(move || {
        App::new()
            .app_data(counter.clone())
            .route("/", web::get().to(get))
    }).bind(("127.0.0.1", 8080))?.run().await
}

编译这段代码并得到错误：

error[E0716]: temporary value dropped while borrowed
  --> src/main.rs:30:23
   |
30 |     let mut readers = data.lock().unwrap().get_readers("1,2")?;
   |                       ^^^^^^^^^^^^^^^^^^^^                    - temporary value is freed at the end of this statement
   |                       |
   |                       creates a temporary value which is freed while still in use
31 |     if readers.is_empty() {
   |        ------- borrow later used here
   |
   = note: consider using a `let` binding to create a longer lived value

我只想使用互斥锁来保护 HashMap，因为它会在其他路由函数中被更改。我认为从“get_readers”返回的 Vec<&dyn Reader> 对象不应受到保护，因为其中的所有项目都是只读的。那么我该如何解决这个问题呢？谢谢！

我有一个 PostgreSQL 连接信息的结构：

struct PgConf {
    host: String,
    port: i16,
    user: String,
    passwd: String,
    dbname: String
}

现在我必须从 HashMap<String, String> 初始化它：

impl PgConf {
    fn init(&mut self, args: &ArgList) -> () {
        if let Some(val) = args.get("host") {
            self.host = val.clone();
        }
        if let Some(val) = args.get("port") {
            self.port = val.parse().unwrap_or(5432);
        }
        if let Some(val) = args.get("user") {
            self.user = val.clone();
        }
        if let Some(val) = args.get("passwd") {
            self.passwd = val.clone();
        }
        if let Some(val) = args.get("db") {
            self.dbname = val.clone();
        }
    }
}

我觉得上面的代码有点臃肿。有更好的方法来实现这一目标吗？