mvarjon/plan9 - Change JDHEU3V74X2S4XHZQKWZIN4DPY7X3QZCIKMF7UYNUO3ZTLQLK55AC

Revision 4 of the Mediator struct (starting point for async).

Created by mvarjon on August 2, 2022

JDHEU3V74X2S4XHZQKWZIN4DPY7X3QZCIKMF7UYNUO3ZTLQLK55AC

Dependencies

In channels

main

Change contents

Replacement in src/mediator.rs at line 1 [2.36]

B:BD[2.36] → [2.37:1169]

use std::collections::HashMap;
pub struct Message {
    pub kind: String,
    pub json: String,
}
pub trait MessageHandler {
    fn handle(&self, msg: &Message);
}
pub struct Mediator {
    storage: HashMap<String, Vec<&'static dyn MessageHandler>>,
}
impl Mediator {
    pub fn new() -> Self {
        Self {
            storage: HashMap::with_capacity(100),
        }
    }
    pub fn add(&mut self, kind: String, handler: &'static dyn MessageHandler) {
        let key = kind.clone();
        if self.storage.contains_key(&key) {
            let handlers = self.storage.get_mut(&key).unwrap();
            handlers.push(handler);
        } else {
            let mut handlers: Vec<&'static dyn MessageHandler> = Vec::new();
            handlers.push(handler);
            self.storage.insert(key, handlers);
        }
    }
    pub fn invoke(&self, msg: &Message) {
        let kind = msg.kind.clone();
        if self.storage.contains_key(&kind) {
            let handlers = self.storage.get(&kind).unwrap();
            for handler in handlers {
                handler.handle(msg);
            }
        }
    }
}

[2.36]

use std::collections::HashMap;
use std::sync::RwLock;
pub struct Message {
    pub kind: String,
    pub json: String,
}
pub type Implementation = fn(&Message) -> ();
struct MessageHandler {
    implementation: Implementation,
}
impl MessageHandler {
    pub fn new(implementation: Implementation) -> Self {
        Self { implementation }
    }
    pub fn handle(&self, msg: &Message) {
        let _ = &(self.implementation)(msg);
    }
}
pub struct Mediator {
    storage: RwLock<HashMap<String, Vec<Implementation>>>,
}
impl Mediator {
    pub fn new() -> Self {
        let data = HashMap::with_capacity(100);
        let storage = RwLock::new(data);
        Self { storage }
    }
    pub fn add(&mut self, kind: String, handler: Implementation) {
        let key = kind.clone();
        let mut backing = self.storage.write().unwrap();
        let target = &mut *backing;
        if target.contains_key(&key) {
            let handlers = target.get_mut(&key).unwrap();
            handlers.push(handler);
        } else {
            let mut handlers: Vec<Implementation> = Vec::new();
            handlers.push(handler);
            target.insert(key, handlers);
        }
    }
    pub fn invoke(&self, msg: &Message) {
        let backing = self.storage.read().unwrap();
        let target = &*backing;
        if !target.contains_key(&msg.kind) {
            return;
        }
        let handlers = target.get(&msg.kind).unwrap();
        for handler in handlers {
            let wrapper = MessageHandler::new(*handler);
            wrapper.handle(msg);
        }
    }
}

Replacement in src/main.rs at line 1 [3.49]

B:BD[3.49] → [4.746:804]

use crate::mediator::{Mediator, Message, MessageHandler};

[3.49]

[4.804]

use mediator::Implementation;
use crate::mediator::{Mediator, Message};

Deletion in src/main.rs at line 6 [3.49]
∅:D[5.354] → [3.50:62]
B:BD[3.49] → [3.50:62]
B:BD[3.62] → [4.806:839]
```
fn main() {
    let mut m = Mediator::new();
```

Replacement in src/main.rs at line 7 [3.49]

B:BD[4.840] → [6.1133:1236]

    m.add(String::from("TEST-3"), &HandleThis {});
    m.add(String::from("TEST-3"), &HandleThis2 {});

[4.840]

[4.941]

#[tokio::main]
async fn main() {
    let mut mediator = Mediator::new();

Replacement in src/main.rs at line 11 [3.49]

B:BD[4.942] → [4.942:966]

B:BD[4.966] → [6.1237:1275]

∅:D[6.1275] → [4.1004:1058]

B:BD[4.1004] → [4.1004:1058]

    let msg = Message {
        kind: String::from("TEST-3"),
        json: String::from("{key: \"data\"}"),
    };

[4.942]

[4.1058]

    let run = tokio::spawn(async move {
        let printer_1: Implementation = message_handler_1;
        let printer_2: Implementation = message_handler_2;

Replacement in src/main.rs at line 15 [3.49]

B:BD[4.1059] → [4.1059:1079]

B:BD[3.85] → [4.1081:1083]

    m.invoke(&msg);
}

[4.1059]

[4.1083]

        mediator.add(String::from("TEST-3"), printer_1);
        mediator.add(String::from("TEST-3"), printer_2);

Replacement in src/main.rs at line 18 [3.49]

B:BD[4.1084] → [4.1084:1105]

struct HandleThis {}

[4.1084]

[4.1105]

        let msg = Message {
            kind: String::from("TEST-3"),
            json: String::from("{key: \"data\"}"),
        };

Replacement in src/main.rs at line 23 [3.49]

B:BD[4.1106] → [4.1106:1181]

B:BD[4.1181] → [6.1276:1324]

impl MessageHandler for HandleThis {
    fn handle(&self, msg: &Message) {
        println!("INVOKED : 1 = {}", msg.json);

[4.1106]

[4.1212]

        mediator.invoke(&msg);
    });
    let run_result = run.await;
    match run_result {
        Ok(_) => println!("SERVER STOPPED."),
        Err(m) => println!("SERVER ERROR: {}", m),

Replacement in src/main.rs at line 34 [3.49]

B:BD[4.1220] → [4.1220:1242]

struct HandleThis2 {}

[4.1220]

[4.1242]

fn message_handler_1(msg: &Message) {
    println!("PRINT 1 : {}", msg.json);
}

Replacement in src/main.rs at line 38 [3.49]

B:BD[4.1243] → [4.1243:1319]

B:BD[4.1319] → [6.1325:1373]

∅:D[6.1373] → [4.1362:1368]

B:BD[4.1362] → [4.1362:1368]

impl MessageHandler for HandleThis2 {
    fn handle(&self, msg: &Message) {
        println!("INVOKED : 2 = {}", msg.json);
    }

[4.1243]

[4.1368]

fn message_handler_2(msg: &Message) {
    println!("PRINT 2 : {}", msg.json);