Channels

Concurrency is an essential concept in modern programming. This challenge focuses on building a message processing system using Rust's channels and threads. You'll create a system where multiple producers send messages with different priority levels, and a single consumer processes and formats these messages.

Your Task

Implement three key functions that work with a message processing system:

create_message_channel() - Creates a channel for sending Message structs
create_producer_thread() - Creates a thread that analyzes and forwards messages
create_consumer_thread() - Creates a thread that formats and collects messages

Requirements

Producer Thread

Receives a vector of messages and a sender channel
Updates priority based on content keywords:
- "ERROR" → Critical
- "WARNING" → High
- "DEBUG" → Medium
- Others become Low
Sends each updated message through the channel

Consumer Thread

Receives messages until the channel is closed
Formats each message as: [PRIORITY|SENDER_ID] CONTENT where PRIORITY is one of: LOW, MED, HIGH, CRIT
Returns a vector of formatted message strings

Notes

Ignore error handling, you can simply unwrap()
Have a look at the main function to see how the functions are used.

Hints

Here are some tips to help you get started:

Click here for implementation hints

Use mpsc::channel() to create the message channel
Use thread::spawn and move closures
Use while let Ok(msg) = rx.recv() for receiving
Format with format!("[{}|{}] {}", priority, id, content)

Editor not available on Mobile!

In order to solve the challenge, please visit this page on a desktop computer.

Solutions

AKA.MoneyTaker

M4Bo2

2 days ago

5.02ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Priority {
    fn as_str(&self) -> &'static str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MEDIUM",
            Priority::High => "HIGH",
            Priority::Critical => "CRITICAL",
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut msg in messages {
            msg.priority = update_priority(&msg.content);
            tx.send(msg).unwrap();
        }
    })
}
fn update_priority(content: &str) -> Priority {
    if content.contains("WARNING") {
        Priority::High
    } else if content.contains("ERROR") {
        Priority::Critical
    } else {
        Priority::Low
    }
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut formatted_messages = Vec::new();
        for msg in rx {
            let formatted = format!("[{}|{}] {}", msg.priority.as_str(), msg.sender_id, msg.content);
            formatted_messages.push(formatted);
        }
        formatted_messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx); // Drop the sender to close the channel and allow the consumer to finish
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

ludovicknecht

3 days ago

5.46ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
#[derive(Debug)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Priority {
    fn str(&self) -> &'static str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT",
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
fn priority_filter(content: String) -> Priority {
    if content.contains("ERROR") {
        return Priority::Critical;
    } else if content.contains("WARNING") {
        return Priority::High;
    } else if content.contains("DEBUG") {
        return Priority::Medium;
    } 
    return Priority::Low;
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel::<Message>()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(
        move || {
            for mut m in messages {
                m.priority = priority_filter(m.content.clone());
                tx.send(m).unwrap();
            }
        }
    )
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(
        move || {
            let mut fmt_msg = vec![];
            while let Ok(m) = rx.recv() {
                fmt_msg.push(format!("[{:?}|{}] {}", m.priority.str(), m.sender_id, m.content));
            }
            fmt_msg
        }
    )
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

manuelmj

4 days ago

7.58ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
use std::fmt; 
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl fmt::Display for Priority{
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MED"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRIT"),
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
impl Message{
    fn get_priority(&mut self){
        self.priority = match &self.content {
            msg if msg.contains("ERROR") => Priority::Critical,
            msg if msg.contains("WARNING") => Priority::High,
            msg if msg.contains("DEBUG") => Priority::Medium,
            _ => Priority::Low,
        };
    }
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    let (tx, rx): (Sender<Message>, Receiver<Message>) = mpsc::channel(); 
    (tx, rx) 
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    let the_thread = thread::spawn(move ||{
        messages.into_iter().for_each(|mut message| {message.get_priority(); tx.send(message).unwrap()});
    });
    the_thread
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    let handler = thread::spawn(move || {
        let mut vec_result : Vec<String> = Vec::new(); 
        while let Ok(message) = rx.recv(){
            let result = format!("[{}|{}] {}", message.priority, message.sender_id, message.content);
            vec_result.push(result); 
        }
        vec_result 
    }); 
    handler 
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Ayushman Rathore

Spartan09

5 days ago

5.11ms

90.99kb

use std::fmt::{self, Display, Formatter};
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            Self::Critical => write!(f, "CRIT"),
            Self::High => write!(f, "HIGH"),
            Self::Medium => write!(f, "MEDIUM"),
            Self::Low => write!(f, "LOW"),
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
impl Display for Message {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        write!(f, "[{}|{}] {}", self.priority, self.sender_id, self.content)
    }
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    let (tx, rx) = mpsc::channel();
    (tx, rx)
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    thread::spawn(move || {
        for mut message in messages.into_iter() {
            message.priority = determine_priority(&message);
            let _ = tx.send(message);
        }
    })
}
fn determine_priority(message: &Message) -> Priority {
    match message.content {
        _ if message.content.contains("ERROR") => Priority::Critical,
        _ if message.content.contains("WARNING") => Priority::High,
        _ if message.content.contains("DEBUG") => Priority::Medium,
        _ => Priority::Low,
    }
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut results = Vec::new();
        while let Ok(val) = rx.recv() {
            results.push(format!("{}", val));
        }
        results
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Jun Huang

leemars

9 days ago

5.75ms

90.70kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
impl Priority {
    pub fn as_str(&self) -> &'static str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT",
        }
    }
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel::<Message>()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut m in messages.into_iter() {
            m.priority = match m.content {
                _ if m.content.contains("ERROR") => Priority::Critical,
                _ if m.content.contains("WARNING") => Priority::High,
                _ if m.content.contains("DEBUG") => Priority::Medium,
                _ => Priority::Low,
            };
            let _ = tx.send(m);
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = vec![];
        while let Ok(m) = rx.recv() {
            messages.push(format!("[{}|{}] {}", m.priority.as_str(), m.sender_id, m.content));
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Algorab

10 days ago

5.66ms

91.40kb

use std::fmt::{Display, Formatter};
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
#[derive(Debug)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MEDIUM"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRITICAL"),
        }
    }
}
#[derive(Debug)]
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel::<Message>()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        messages.into_iter().for_each(|mut m| {
            m.priority = match m.content.as_str() {
                m if m.contains("ERROR") => Priority::Critical,
                m if m.contains("WARNING") => Priority::High,
                m if m.contains("DEBUG") => Priority::Medium,
                _ => Priority::Low
            };
            println!("m to send: {:?}", m);
            tx.send(m).unwrap();
        })
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = Vec::new();
        while let Ok(m) = rx.recv() {
            let msg = format!("[{}|{}] {}",m.priority, m.sender_id,m.content);
            println!("msg: {}", msg);
            messages.push(msg);
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}
#[cfg(test)]
mod tests {
    use crate::{create_consumer_thread, create_message_channel, create_producer_thread, Message, Priority};
    #[test]
    fn test_message_format() {
        let (tx, rx) = create_message_channel();
        let messages = vec![Message {
            content: "Test message".to_string(),
            sender_id: 42,
            priority: Priority::Medium, // This priority will be overridden
        }];
        let producer_handle = create_producer_thread(messages, tx);
        producer_handle.join().unwrap();
        let consumer_handle = create_consumer_thread(rx);
        let results = consumer_handle.join().unwrap();
        println!("results: {:?}", results);
        assert_eq!(results.len(), 1);
        assert!(
            results[0].contains("LOW")  // Changed from MED to LOW since content has no keywords
                && results[0].contains("42")
                && results[0].contains("Test message"),
            "Message should contain correct priority based on content, ID and content"
        );
    }
}

Kyle Diaz

kylediaz

11 days ago

5.47ms

90.99kb

use std::fmt;
use std::fmt::Display;
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MEDIUM"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRITICAL"),
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut m in messages.into_iter() {
            m.priority = if m.content.contains("ERROR") {
                Priority::Critical
            } else if m.content.contains("WARNING") {
                Priority::High
            } else if m.content.contains("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            };
            tx.send(m).unwrap();
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
            let mut output = vec![];
            while let Ok(msg) = rx.recv() {
                let formatted_message = format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content);
                output.push(formatted_message);
            }
            return output;
        }
    )
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Jordan

Jordan-Haidee

11 days ago

5.90ms

92.08kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut msg in messages {
            msg.priority = if msg.content.starts_with("ERROR") {
                Priority::Critical
            } else if msg.content.starts_with("WARNING") {
                Priority::High
            } else if msg.content.starts_with("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            };
            let _ = tx.send(msg);
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages = vec![];
        while let Ok(msg) = rx.recv() {
            let level = match msg.priority {
                Priority::Critical => "CRIT",
                Priority::High => "HIGH",
                Priority::Medium => "MED",
                Priority::Low => "LOW",
            };
            messages.push(format!("[{}|{}] {}", level, msg.sender_id, msg.content));
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Jordan

Jordan-Haidee

11 days ago

7.13ms

92.12kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut msg in messages {
            msg.priority = if msg.content.starts_with("ERROR") {
                Priority::Critical
            } else if msg.content.starts_with("WARNING") {
                Priority::High
            } else if msg.content.starts_with("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            };
            let _ = tx.send(msg);
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages = vec![];
        while let Ok(msg) = rx.recv() {
            let level = match msg.priority {
                Priority::Critical => "CRIT",
                Priority::High => "HIGH",
                Priority::Medium => "MED",
                Priority::Low => "LOW",
            };
            messages.push(format!("[{}|{}] {}", level, msg.sender_id, msg.content));
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

rawar089

11 days ago

4.82ms

92.08kb

use std::fmt::Display;
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
impl Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MED"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRIT"),
        }
    }
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel::<Message>()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut m in messages {
            m.priority = match m.content.as_str() {
                m if m.contains("ERROR") => Priority::Critical,
                m if m.contains("WARNING") => Priority::High,
                m if m.contains("DEBUG") => Priority::Medium,
                _ => Priority::Low,
            };
            tx.send(m).unwrap();
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = Vec::new();
        while let Ok(m) = rx.recv() {
            let msg = format!("[{}|{}] {}",m.priority,m.sender_id,m.content);
            messages.push(msg);
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Nikita Smirnov

Nismirno

13 days ago

5.82ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut message in messages {
            if message.content.contains("ERROR") {
                message.priority = Priority::Critical;
            } else if message.content.contains("WARNING") {
                message.priority = Priority::High;
            } else if message.content.contains("DEBUG") {
                message.priority = Priority::Medium;
            } else {
                message.priority = Priority::Low;
            }
            let _ = tx.send(message);
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut result: Vec<String> = Vec::new();
        while let Ok(msg) = rx.recv() {
            let priority = match msg.priority {
                Priority::Critical => "CRIT",
                Priority::High => "HIGH",
                Priority::Medium => "MED",
                Priority::Low => "LOW",
            };
            result.push(format!("[{}|{}] {}", priority, msg.sender_id, msg.content));
        }
        result
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

alemack17

14 days ago

5.06ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        let _=messages.into_iter()
            .for_each(|mut mess| {
                if mess.content.contains("ERROR"){
                    mess.priority=Priority::Critical;
                }else if mess.content.contains("WARNING"){
                    mess.priority=Priority::High;
                }else if mess.content.contains("DEBUG"){
                    mess.priority=Priority::Medium;
                }else{
                    mess.priority=Priority::Low;
                }
                tx.send(mess).unwrap()
            });
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut ret=vec![];
        while let Ok(msg) = rx.recv(){
            let priority=match msg.priority{
                Priority::Low=>"LOW",
                Priority::Medium=>"MED",
                Priority::High=>"HIGH",
                Priority::Critical=>"CRIT",
            };
            ret.push(format!("[{}|{}] {}", priority, msg.sender_id, msg.content));
        }
        ret
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Christopher Nielson

c-nielson

16 days ago

4.56ms

92.01kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
#[derive(Debug)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Priority {
    fn as_str(&self) -> &str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MEDIUM",
            Priority::High => "HIGH",
            Priority::Critical => "CRITICAL",
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    thread::spawn(move || {
        for mut message in messages.into_iter() {
            message.priority = if message.content.contains("ERROR") {
                Priority::Critical
            } else if message.content.contains("WARNING") {
                Priority::High
            } else if message.content.contains("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            };
                
            tx.send(message).unwrap();
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut formatted: Vec<String> = vec![];
        
        while let Ok(message) = rx.recv() {
            formatted.push(format!("[{}|{}] {}", &message.priority.as_str(), &message.sender_id, &message.content));
        }
        
        formatted
    })
}

Elliott Draper

ejdraper

19 days ago

5.62ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl std::fmt::Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MEDIUM"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRITICAL")
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    return mpsc::channel();
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut msg in messages {
            msg.priority = if msg.content.contains("DEBUG") {
                Priority::Medium
            } else if msg.content.contains("WARNING") {
                Priority::High
            } else if msg.content.contains("ERROR") {
                Priority::Critical
            } else {
                Priority::Low
            };
            tx.send(msg);
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = vec![];
        while let Ok(msg) = rx.recv() {
            messages.push(format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content));
        }
        return messages;
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

kosay

sarub0b0

19 days ago

4.72ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl std::fmt::Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MED"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRIT"),
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    thread::spawn(move || {
        for mut msg in messages {
            msg.priority = match msg.content.as_str() {
                msg if msg.contains("ERROR") => Priority::Critical,
                msg if msg.contains("WARNING") => Priority::High,
                msg if msg.contains("DEBUG") => Priority::Medium,
                _ => Priority::Low,
            };
            tx.send(msg).unwrap();
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut results = vec![];
        while let Ok(msg) = rx.recv() {
            let formatted_msg = format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content);
            results.push(formatted_msg);
        }
        results
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Oebelus

oebelus

21 days ago

4.87ms

90.99kb

use std::fmt::Display;
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut message in messages {
            message.priority = match message.content.as_str() {
                message if message.contains("ERROR") => Priority::Critical,
                message if message.contains("DEBUG") => Priority::Medium,
                message if message.contains("WARNING") => Priority::High,
                _ => Priority::Low,
            };
            tx.send(message).unwrap();
        }
    })
}
impl Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MEDIUM"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRITICAL"),
        }
    }
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = Vec::new();
        while let Ok(msg) = rx.recv() {
            messages.push(format!(
                "[{}|{}] {}",
                msg.priority, msg.sender_id, msg.content
            ));
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Oebelus

oebelus

21 days ago

5.49ms

90.99kb

use std::fmt::Display;
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut message in messages {
            message.priority = match message.content.as_str() {
                message if message.contains("ERROR") => Priority::Critical,
                message if message.contains("DEBUG") => Priority::Medium,
                message if message.contains("WARNING") => Priority::High,
                _ => Priority::Low,
            };
            tx.send(message).unwrap();
        }
    })
}
impl Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MEDIUM"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRITICAL"),
        }
    }
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = Vec::new();
        while let Ok(msg) = rx.recv() {
            messages.push(format!(
                "[{}|{}] {}",
                msg.priority, msg.sender_id, msg.content
            ));
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Jonathan Voss

jvoss

22 days ago

4.54ms

92.12kb

use std::fmt::Display;
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};

pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}

impl Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            Priority::Low => write!(f, "LOW"),
            Priority::Medium => write!(f, "MED"),
            Priority::High => write!(f, "HIGH"),
            Priority::Critical => write!(f, "CRIT")
        }
    }
}

pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}

pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    mpsc::channel()
}

pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    thread::spawn(move || {
        messages
            .into_iter()
            .for_each(|mut message| {
                if message.content.contains("ERROR") {
                    message.priority = Priority::Critical;
                } else if message.content.contains("WARNING") {
                    message.priority = Priority::High;
                } else if message.content.contains("DEBUG") {
                    message.priority = Priority::Medium;
                } else {
                    message.priority = Priority::Low;
                }

                // - Sends the updated message through the channel      
                tx.send(message).unwrap();
            });
    })
}

pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = Vec::new();

        while let Ok(msg) = rx.recv() {
            messages.push(format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content));
        }
            
        messages
    })
}

// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();

    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }

    drop(tx);
    let consumer_handle = create_consumer_thread(rx);

    for handle in producer_handles {
        handle.join().unwrap();
    }

    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

TaiPoole

22 days ago

4.91ms

92.01kb

use std::fmt::{Display, Formatter};
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
#[derive(Debug)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", match self {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT"
        })
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move|| {messages.into_iter().for_each(|mut message| { 
        message.priority = {
            if message.content.contains("ERROR") {
                Priority::Critical
            } else if message.content.contains("WARNING") {
                Priority::High
            } else if message.content.contains("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            }
        };
        let _ = tx.send(message);
    })})
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    
    thread::spawn(move || {
        let mut messages = vec![];
        while let Ok(msg) = rx.recv() {
            messages.push(format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content))
        };
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Justin Maillet

justy777

23 days ago

5.78ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
#[derive(Debug)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl std::fmt::Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result<> {
        let msg = match self {
            Self::Low => "LOW",
            Self::Medium => "MED",
            Self::High => "HIGH",
            Self::Critical => "CRIT",
        };
        write!(f, "{msg}")
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    thread::spawn(move || {
        messages.into_iter().for_each(|mut message| {
            message.priority = if message.content.contains("ERROR") {
                Priority::Critical
            } else if message.content.contains("WARNING") {
                Priority::High
            } else if message.content.contains("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            };
            let _ = tx.send(message);
        })
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut formatted_messages = Vec::new();
        while let Ok(message) = rx.recv() {
            formatted_messages.push(format!("[{}|{}] {}", message.priority, message.sender_id, message.content));
        }
        formatted_messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Jim Lawton

jimlawton

23 days ago

5.63ms

92.12kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
use std::fmt::Display;
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Priority::Critical => write!(f, "CRIT"),
            Priority::High => write!(f, "HIGH"),
            Priority::Medium => write!(f, "MED"),
            Priority::Low => write!(f, "LOW"),
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    thread::spawn(move || {
        messages
            .into_iter()
            .for_each(|mut msg| {
                if msg.content.contains("ERROR:") {
                    msg.priority = Priority::Critical;
                } else if msg.content.contains("WARNING:") {
                    msg.priority = Priority::High;
                } else if msg.content.contains("DEBUG:") {
                    msg.priority = Priority::Medium;
                } else {
                    msg.priority = Priority::Low;
                }
                let _ = tx.send(msg);
            }
        )
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut messages: Vec<String> = Vec::new();
        while let Ok(msg) = rx.recv() {
            messages.push(format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content))
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

Stefan Roas

sroas

23 days ago

6.40ms

90.99kb

use std::fmt::Display;
use std::sync::mpsc::{channel, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Priority::Critical => write!(f, "CRIT"),
            Priority::High => write!(f, "HIGH"),
            Priority::Medium => write!(f, "MED"),
            Priority::Low => write!(f, "LOW"),
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    channel::<Message>()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        messages.into_iter().for_each(|mut m| {
            if m.content.starts_with("ERROR") {
                m.priority = Priority::Critical;
            } else if m.content.starts_with("WARNING") {
                m.priority = Priority::High;
            } else if m.content.starts_with("DEBUG") {
                m.priority = Priority::Medium;
            } else {
                m.priority = Priority::Low;
            }
            tx.send(m).unwrap();
        })
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages = vec![];
        while let Ok(m) = rx.recv() {
            messages.push(format!("[{}|{}] {}", m.priority, m.sender_id, m.content));
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

dawwestk

a month ago

4.43ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Priority {
    pub fn as_str(&self) -> &'static str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT",
        }
    }
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    std::sync::mpsc::channel::<Message>()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        for mut m in messages.into_iter() {
            m.priority = if m.content.starts_with("ERROR") {
                Priority::Critical
            } else if m.content.starts_with("WARNING") {
                Priority::High
            } else if m.content.starts_with("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            };
            tx.send(m).unwrap();
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut messages: Vec<String> = vec![];
        while let Ok(m) = rx.recv() {
            messages.push(format!("[{}|{}] {}", m.priority.as_str(), m.sender_id, m.content));
        }
        messages
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}

PangoSea

kapaseker

a month ago

4.41ms

91.00kb

use std::sync::mpsc::{self, Receiver, Sender,channel};
use std::thread::{self, JoinHandle};
#[derive(Clone)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
pub struct Message {
    pub content: String,
    pub sender_id: u32,
    pub priority: Priority,
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        messages.iter().for_each(|m| {
            let mut msg = Message {
                priority: Priority::Low,
                content: m.content.clone(),
                sender_id: m.sender_id,
            };
            if m.content.starts_with("ERROR") {
                msg.priority = Priority::Critical;
            } else if m.content.starts_with("WARNING") {
                msg.priority = Priority::High;
            } else if m.content.starts_with("DEBUG") {
                msg.priority = Priority::Medium;
            }
            tx.send(msg).unwrap();
        });
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    // TODO: Create a thread that:
    // - Receives messages from the channel
    // - Formats them as "[PRIORITY|SENDER_ID] CONTENT"
    // - Returns a vector of formatted messages
    thread::spawn(move || {
        let mut vec: Vec<String> = vec![];
        rx.iter().for_each(|m| {
            vec.push(format!("[{}|{}] {}", match m.priority {
                Priority::Low => "LOW",
                Priority::Medium => "MED",
                Priority::High => "HIGH",
                Priority::Critical => "CRIT",
            }, m.sender_id, m.content));
        });
        vec
    })
}
// Example Usage
pub fn main() {
    let (tx, rx) = create_message_channel();
    let mut producer_handles = vec![];
    for id in 0..3 {
        let tx_clone = tx.clone();
        let messages = vec![
            Message {
                content: format!("Normal message from producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("WARNING: System running hot on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
            Message {
                content: format!("ERROR: Connection lost on producer {}", id),
                sender_id: id,
                priority: Priority::Low,
            },
        ];
        let handle = create_producer_thread(messages, tx_clone);
        producer_handles.push(handle);
    }
    drop(tx);
    let consumer_handle = create_consumer_thread(rx);
    for handle in producer_handles {
        handle.join().unwrap();
    }
    let results = consumer_handle.join().unwrap();
    println!("Processed messages:");
    for msg in results {
        println!("{}", msg);
    }
}