有没有一种方法可以层叠titleTemplate？

Question

我正在这里探索可能性。是否可以通过继承父项的titleTemplate来实现类似的目的？

use std::thread;
use std::time::{Duration};
use std::sync::Arc;
use crossbeam::queue::SegQueue;
use parking_lot::{Mutex, MutexGuard};

struct ReadySignal {
    client_id: usize,
    client:  Arc<Mutex<Client>>,
    section: usize,
}

struct Client {
    id:      usize,
    file:    Vec<usize>,
}

fn main() {
    let max_clients = 10;
    let file_size = 1000;
    let req_q = Arc::new(SegQueue::new());
    let v: Vec<Arc<Mutex<Client>>> = Vec::new();
    let client_arr = Arc::new(Mutex::new(v));
    let client_arr_c = Arc::clone(&client_arr);
    thread::spawn(move || {
        loop {
            thread::sleep(Duration::from_millis(10));
            let mut display = String::new();
            let client_arr_c = client_arr_c.lock();
            for (_ii, i) in client_arr_c.iter().enumerate() {

                let client = i.lock();
                let total = client.file.len();
                let mut done = 0;
                for j in client.file.iter() {
                    if *j == 1 {
                        done += 1;
                    }
                }
                let percentage = (done as f64/total as f64) * 100.0;
                let client_per: String = format!("Client {}: {:.2}%\n", client.id, percentage);
                MutexGuard::unlock_fair(client);
                display += &client_per;
            }
            MutexGuard::unlock_fair(client_arr_c);
            println!("\x1B[2J\x1B[1;1H{}",display);
            
        }
    });
    let client_arr_c = Arc::clone(&client_arr);
    std::thread::spawn(move || {
        for i in 0..max_clients {
            thread::sleep(Duration::from_millis(1000));
            let mut file_init = 0;
            if i == 0 {
                file_init = 1;
            }
            let client_id = i + 1;
            let client = Arc::new(Mutex::new(Client{
                id: client_id,
                file: vec![file_init;file_size],
            }));
            let clientc = Arc::clone(&client);
            let req_qc = Arc::clone(&req_q);
            thread::spawn(move || {
                for j in 0..file_size {
                    thread::sleep(Duration::from_millis(10));
                    let clientcc = clientc.lock();
                    if clientcc.file[j] == 0 {
                        let req = ReadySignal{
                            client_id,
                            client: Arc::clone(&clientc),
                            section: j,
                        };
                        MutexGuard::unlock_fair(clientcc);
                        req_qc.push(req);
                        continue;
                    }
                    
                }
            });
            let clientc = Arc::clone(&client);
            let req_qc = Arc::clone(&req_q);
            thread::spawn(move || {
                loop {
                    thread::sleep(Duration::from_millis(20));
                    let req = match req_qc.pop() {
                        Err(_) => continue,
                        Ok(x) => x,
                    };
                    let (clientc, mut req_client) = match client_id.cmp(&req.client_id) {
                        std::cmp::Ordering::Less => {
                            let a = clientc.lock();
                            let b =  req.client.lock();
                            (a, b)
                        }
                        std::cmp::Ordering::Greater => {
                            let b =  req.client.lock();
                            let a = clientc.lock();
                            (a, b)
                        }
                        std::cmp::Ordering::Equal => {
                            req_qc.push(req);
                            continue;
                        }
                    };
                    if clientc.file[req.section] == 1 {
                        req_client.file[req.section] = 1;
                        MutexGuard::unlock_fair(req_client);
                        MutexGuard::unlock_fair(clientc);
                    } else {
                        MutexGuard::unlock_fair(req_client);
                        MutexGuard::unlock_fair(clientc);
                        req_qc.push(req);
                    }
                }
            });
            let clientc = Arc::clone(&client);
            client_arr_c.lock().push(clientc);
        }
    });
    loop {
        thread::sleep(Duration::from_millis(1000));
    }
}

当我尝试做这样的事情时，子titleTemplate似乎超过了父项的所有规则。您的titleTemplate中是否有要引用的变量？