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

Viktor Merkurev

fennr

2 days ago

6.39ms

92.16kb

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 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 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 || {
        messages.into_iter().for_each(|mut item| {
            let priority = if item.content.starts_with("ERROR") {
                Priority::Critical
            } else if item.content.starts_with("WARNING") {
                Priority::High
            } else if item.content.starts_with("DEBUG") {
                Priority::Medium
            } else {
                Priority::Low
            };
            item.priority = priority;
            tx.send(item).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 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);
    }
}

Nguyen Vo Hoang Son

sonmessia

3 days ago

5.68ms

91.05kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
use std::fmt::Display;
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::Critical => write!(f, "CRIT"),
            Priority::High => write!(f, "HIGH"),
            Priority::Medium => write!(f, "MED"),
            _ => write!(f, "LOW")
        }
    }
}
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.starts_with("ERROR") {
                    message.priority = Priority::Critical;
                } else if message.content.starts_with("WARNING") {
                    message.priority = Priority::High;
                } else if message.content.starts_with("DEBUG") {
                    message.priority = Priority::Medium;
                } else {
                    message.priority = Priority::Low;
                }
                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 messages = Vec::new();
        for msg in rx {
            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);
    }
}

Liyqq

11 days ago

9.15ms

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,
}
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
    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| {
            let 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
            };
            m.priority = priority;
            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 || {
        rx.into_iter()
            .map(|m| {
                format!("[{}|{}] {}", m.priority, m.sender_id, m.content)
            })
            .collect()
    })
}
// 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);
    }
}

shibu-t

12 days ago

7.76ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
use std::fmt::{Display, Formatter, Result};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut Formatter) -> Result {
        match self {
            Priority::Critical => write!(f, "CRIT"),
            Priority::High => write!(f, "HIGH"),
            Priority::Medium => write!(f, "MED"),
            _ => 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
    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;
            }
            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 results = vec![];
        while let Ok(msg) = rx.recv() {
            let formatted_message = format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content);
            results.push(formatted_message);
        }
        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);
    }
}

lugtester

a month ago

4.80ms

90.99kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
use std::fmt::{Display, Formatter, Result};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut Formatter) -> Result {
        match self {
            Priority::Critical => write!(f, "CRIT"),
            Priority::High => write!(f, "HIGH"),
            Priority::Medium => write!(f, "MED"),
            _ => 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
    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.starts_with("ERROR") {
                    message.priority = Priority::Critical;
                } else if message.content.starts_with("WARNING") {
                    message.priority = Priority::High;
                } else if message.content.starts_with("DEBUG") {
                    message.priority = Priority::Medium;
                } else {
                    message.priority = Priority::Low;
                }
                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 my_vec = Vec::new();
            while let Ok(result) = rx.recv() {
                my_vec.push(format!("[{}|{}] {}", result.priority, result.sender_id, result.content));
            }
            my_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);
    }
}

Jason

Jason-fy-wang

a month ago

6.87ms

91.00kb

use std::sync::mpsc::{self,channel, Receiver, Sender};
use std::thread::{self, JoinHandle};
#[derive(Clone, Debug)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
#[derive(Clone)]
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
    let (tx, send) = channel::<Message>();
    (tx, send)
}
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(|msg| {
            let mut mg = msg.clone();
            if mg.content.contains("ERROR") {
                mg.priority = Priority::Critical;
            }else if mg.content.contains("WARNING") {
                mg.priority = Priority::High;
            }else if mg.content.contains("DEBUG") {
                mg.priority = Priority::Medium;
            }else {
                mg.priority = Priority::Low;
            }
            tx.send(mg).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 || {
        rx.into_iter()
            .map(|msg| {
                
                let priority = match msg.priority {
                    Priority::Low => "LOW",
                    Priority::Medium => "MED",
                    Priority::High => "HIGH",
                    Priority::Critical => "CRIT",
                };
                
                format!("[{}|{}] {}", priority, msg.sender_id, msg.content)
            })
            .collect::<Vec<String>>()
    })
}
// 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);
    }
}

sriharsha madala

sriharshamadala

a month ago

5.69ms

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 {
            Self::Low => write!(f, "LOW"),
            Self::Medium => write!(f, "MED"),
            Self::High => write!(f, "HIGH"),
            Self::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::<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 msg in messages {
            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;
            }
            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 messages = Vec::new();
        for msg in rx {
            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);
    }
}

AnKarl

Zythophilus

a month ago

5.76ms

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
    std::thread::spawn(move || messages.into_iter().for_each(|mut msg| {
        msg.priority = match msg.content.as_str() {
            s if s.starts_with("ERROR") => Priority::Critical,
            s if s.starts_with("WARNING") => Priority::High,
            s if s.starts_with ("DEBUG") => Priority::Medium,
            _ => Priority::Low,
        };
        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
    std::thread::spawn(move || {
        let mut res = Vec::new();
        while let Ok(msg) = rx.recv() {
            let prio = match msg.priority {
                Priority::Critical => "CRIT",
                Priority::Medium => "MED",
                Priority::High => "HIGH",
                _ => "LOW",
            };
            res.push(format!("[{}|{}] {}", prio, msg.sender_id, msg.content))   
        }
        res
    })
}
// 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);
    }
}

vijayabhaskar badireddi

ptcte

a month ago

5.33ms

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>) {
    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 = match message.content.as_str() {
                    content if content.starts_with("ERROR") => Priority::Critical,
                    content if content.starts_with("WARNING") => Priority::High,
                    content if content.starts_with("DEBUG") => Priority::Medium,
                    _ => Priority::Low,
                };
                tx.send(message).unwrap();
            });
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || { 
        let mut messages = vec![];
        while let Ok(msg) = rx.recv() {
            let priority = match msg.priority {
                Priority::Low => "LOW",
                Priority::Medium => "MED",
                Priority::High => "HIGH",
                Priority::Critical => "CRIT",
            };
            messages.push(format!("[{:?}|{}] {}", 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);
    }
}

Jason

chenjie1219

a month ago

5.46ms

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>) {
    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 = match message.content.as_str() {
                    content if content.starts_with("ERROR") => Priority::Critical,
                    content if content.starts_with("WARNING") => Priority::High,
                    content if content.starts_with("DEBUG") => Priority::Medium,
                    _ => Priority::Low,
                };
                tx.send(message).unwrap();
            });
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || { 
        let mut messages = vec![];
        while let Ok(msg) = rx.recv() {
            let priority = match msg.priority {
                Priority::Low => "LOW",
                Priority::Medium => "MED",
                Priority::High => "HIGH",
                Priority::Critical => "CRIT",
            };
            messages.push(format!("[{:?}|{}] {}", 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);
    }
}

Yixian Du

duyixian1234

2 months ago

5.58ms

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>) {
    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 = match message.content.as_str() {
                    content if content.starts_with("ERROR") => Priority::Critical,
                    content if content.starts_with("WARNING") => Priority::High,
                    content if content.starts_with("DEBUG") => Priority::Medium,
                    _ => Priority::Low,
                };
                tx.send(message).unwrap();
            });
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || { 
        let mut messages = vec![];
        while let Ok(msg) = rx.recv() {
            let priority = match msg.priority {
                Priority::Low => "LOW",
                Priority::Medium => "MED",
                Priority::High => "HIGH",
                Priority::Critical => "CRIT",
            };
            messages.push(format!("[{:?}|{}] {}", 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);
    }
}

Kentaro Abe

abekem

2 months ago

11.64ms

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>) {
    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 = match message.content.as_str() {
                    content if content.starts_with("ERROR") => Priority::Critical,
                    content if content.starts_with("WARNING") => Priority::High,
                    content if content.starts_with("DEBUG") => Priority::Medium,
                    _ => Priority::Low,
                };
                tx.send(message).unwrap();
            });
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || { 
        let mut messages = vec![];
        while let Ok(msg) = rx.recv() {
            let priority = match msg.priority {
                Priority::Low => "LOW",
                Priority::Medium => "MED",
                Priority::High => "HIGH",
                Priority::Critical => "CRIT",
            };
            messages.push(format!("[{:?}|{}] {}", 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);
    }
}

Aurimas Kuniutis

auriku

2 months ago

4.94ms

92.19kb

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 {
        let priority_str = match self {
            Priority::Low => "LOW",
            Priority::Medium => "MEDIUM",
            Priority::High => "HIGH",
            Priority::Critical => "CRITICAL",
        };
        write!(f, "{}", priority_str)
    }
}
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 = match message.content.as_str() {
                content if content.contains("ERROR") => Priority::Critical,
                content if content.contains("WARNING") => Priority::High,
                content if content.contains("DEBUG") => Priority::Medium,
                _ => Priority::Low,
            };
            tx.send(message).unwrap();
        });
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut formatted_messages = vec![];
        while let Ok(msg) = rx.recv() {
            formatted_messages.push(format!(
                "[{}|{}] {}",
                msg.priority, msg.sender_id, msg.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);
    }
}

Artem

tich31337

2 months ago

5.70ms

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 {
        let text = match self {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT"
        };
        write!(f, "{}", text)
    }
}
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 || {
        messages.into_iter().for_each(|mut x| {
            x.priority = match &x.content {
                t if t.starts_with("ERROR") => Priority::Critical,
                t if t.starts_with("WARNING") => Priority::High,
                t if t.starts_with("DEBUG") => Priority::Medium,
                _ => Priority::Low,
            };
            tx.send(x).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 v: Vec<String> = Vec::new();
        while let Ok(msg) = rx.recv() {
            v.push(format!("[{}|{}] {}", msg.priority, msg.sender_id, msg.content));
        };
        v
    })
}
// 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);
    }
}

Paulo Lins

pblins

2 months ago

6.01ms

90.88kb

use std::fmt::Display;
use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{spawn, JoinHandle};
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Display for Priority {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let s = match self {
            Priority::Low => "LOW",
            Priority::Medium => "MEDIUM",
            Priority::High => "HIGH",
            Priority::Critical => "CRITICAL",
        };
        write!(f, "{}", s)
    }
}
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
    //
    spawn(|| {
        messages
            .into_iter()
            .map(|mut m| {
                match m.content.as_str() {
                    c if c.contains("ERROR") => m.priority = Priority::Critical,
                    c if c.contains("WARNING") => m.priority = Priority::High,
                    c if c.contains("DEBUG") => m.priority = Priority::Medium,
                    _ => m.priority = Priority::Low,
                }
                m
            })
            .for_each(move |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
    spawn(move || {
        rx.iter().map(|m| format!("[{}|{}] {}", m.priority, m.sender_id, m.content)).collect()
        }
    )
}
// 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);
    }
}

Anna Komarova

Vlasanya

2 months ago

5.51ms

92.22kb

use std::sync::mpsc::{self, Receiver, Sender};
use std::thread::{self, JoinHandle};
#[derive(Debug)]
pub enum Priority {
    Low,
    Medium,
    High,
    Critical,
}
impl Priority {
    pub fn to_str(&self) -> &'static str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT",
        }
    }
}
#[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()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    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;
            }
            tx.send(message).unwrap();
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut formatted_messages = Vec::new();
        while let Ok(msg) = rx.recv() {
            let formatted = format!("[{}|{}] {}", msg.priority.to_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);
    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);
    }
}

Icarus

IcarusxB

2 months ago

7.08ms

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>) {
    mpsc::channel()
}
pub fn create_producer_thread(messages: Vec<Message>, tx: Sender<Message>) -> JoinHandle<()> {
    thread::spawn(move || {
        for mut msg in messages {
            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;
            }
            tx.send(msg).unwrap();
        }
    })
}
pub fn create_consumer_thread(rx: Receiver<Message>) -> JoinHandle<Vec<String>> {
    thread::spawn(move || {
        let mut formatted_messages = Vec::new();
        while let Ok(msg) = rx.recv() {
            let priority = match msg.priority {
                Priority::Low => "LOW",
                Priority::Medium => "MED",
                Priority::High => "HIGH",
                Priority::Critical => "CRIT",
            };
            let formatted = format!("[{}|{}] {}", priority, 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);
    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);
    }
}

Hung Dinh

nhdinh

2 months ago

5.98ms

90.99kb

use std::fmt::{Display, Formatter};
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 Message {
    pub fn update_priority(&mut self) {
        self.priority = match self.content.split_once(": ").unwrap_or(("", "")).0 {
            "ERROR" => Priority::Critical,
            "WARNING" => Priority::High,
            "DEBUG" => Priority::Medium,
            _ => Priority::Low,
        };
    }
}
impl Display for Message {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let priority_str = match self.priority {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT",
        };
        write!(f, "[{}|{}] {}", priority_str, self.sender_id, self.content)
    }
}
pub fn create_message_channel() -> (Sender<Message>, Receiver<Message>) {
    // 1. Implement this function to create and return a message channel
    let (tx, rx) = mpsc::channel::<Message>();
    (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
    thread::spawn(move || {
        for mut msg in messages {
            msg.update_priority();
            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 || rx.iter().map(|msg| format!("{}", msg)).collect())
}
// 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);
    }
}

Matthew Li

circles-png

2 months ago

5.48ms

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
    std::sync::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.split_once(": ").unwrap_or(("", "")).0 {
                "ERROR" => Priority::Critical,
                "WARNING" => Priority::High,
                "DEBUG" => Priority::Medium,
                _ => Priority::Low,
            };
            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 || {
        rx.iter().map(|Message { content, sender_id, priority }| format!("[{}|{sender_id}] {content}", match priority {
            Priority::Low => "LOW",
            Priority::Medium => "MED",
            Priority::High => "HIGH",
            Priority::Critical => "CRIT",
        })).collect()
    })
}
// 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);
    }
}

Zeiion

2 months ago

11.60ms

92.16kb

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<()> {
    // TODO: Create a thread that:
    // - Updates the priority based on content
    // - Sends the updated message through the channel
    thread::spawn(move || {
        messages.into_iter().map(|msg| {
            let mut priority = Priority::Low;
            if msg.content.contains("ERROR") {
                priority = Priority::Critical;
            } else if msg.content.contains("WARNING") {
                priority = Priority::High;
            } else if msg.content.starts_with("DEBUG") {
                priority = Priority::Medium;
            }
            Message {
                content: msg.content.clone(),
                sender_id: msg.sender_id,
                priority,
            }
        }).for_each(|msg| {
            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 results = vec![];
        for msg in rx {
            results.push(format!("[{}|{}] {}", msg.priority.as_str(), msg.sender_id, msg.content));
        }
        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);
    }
}

arilet

3 months ago

4.74ms

91.06kb

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 || {
        messages.
        into_iter().
        map (|x| {
                let p = match x.content.clone() {
                    y if y.contains("ERROR")   => Priority::Critical,
                    y if y.contains("WARNING") => Priority::High,
                    y if y.contains("DEBUG")   => Priority::Medium,
                    _ => Priority::Low,
                };
                Message {
                    content:    x.content,
                    sender_id:  x.sender_id,
                    priority:   p,
                }
            }
        ).
        for_each(|x| { tx.send(x).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 v: Vec<String> = Vec::new();
        for msg in rx {
            v.push(
                match msg.priority {
                    Priority::Critical => format!("[CRIT|{}] {}", msg.sender_id, msg.content),
                    Priority::High => format!("[HIGH|{}] {}", msg.sender_id, msg.content),
                    Priority::Medium => format!("[MED|{}] {}", msg.sender_id, msg.content),
                    Priority::Low => format!("[LOW|{}] {}", msg.sender_id, msg.content),
                }
            );
        }
        v
    })
}
// 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);
    }
}

amaneru

7ma8no9

3 months ago

5.54ms

92.16kb

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()
}
impl Priority {
    fn as_str(&self) -> &'static str {
        match self {
            Priority::Low => "LOW",
            Priority::Medium => "MEDIUM",
            Priority::High => "HIGH",
            Priority::Critical => "CRITICAL",
        }
    }
}
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_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 = update_priority(&message.content);
            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();
        for msg in rx {
            messages.push(format!("[{}|{}] {}", msg.priority.as_str(), 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);
    }
}

AKA.MoneyTaker

M4Bo2

3 months 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 months 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);
    }
}

Manuel Manjarres R.

manuelmj

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

3 months 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

4 months 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

4 months 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);
    }
}