Untitled

impl LogThread 
{
    fn thread_create() -> LogThread
    {
        let (sender, mut receiver) = mpsc::channel::<Command>(32);
        let thread = tokio::spawn(async move 
        {
            while let Some(cmd) = receiver.recv().await 
            {
                // -- here i need log_data queue -- //
            }
        });

        LogThread { thread, sender }
    }

    async fn thread_close(self) -> Result<(), tokio::task::JoinError> 
    {
        self.thread.await
    }    
}

pub struct Log
{
    log_data:       VecDeque<LogData>,
    database:       MongoDBConnection,
    thread:         LogThread,
}

impl Log
{
    pub fn log(&mut self, category: &str, subcategory: &str, logtext: &str)
    {
        let log_data_value = LogData::log_data(category, subcategory, logtext);
        self.log_data.push_front(log_data_value);
        self.send_signal();
    }

    fn send_signal(&self)
    {
        block_on(self.thread.sender.send(Command::SendData)).unwrap_or_default()
    }

    fn get_logdata(&self) -> Iter<LogData>
    {
        self.log_data.iter()
    }

    pub async fn close(self)
    {
        let close = self.thread.thread_close();
    }
}