mvarjon/plan9 - Change SDSLUF56O2RWWV23CBCAR52FT7UVCAX6Y4N3LM4EEVWIRIOUP5EQC

Revision 5 of the Mediator structure. Async message invocation available.

Created by mvarjon on August 2, 2022

SDSLUF56O2RWWV23CBCAR52FT7UVCAX6Y4N3LM4EEVWIRIOUP5EQC

Dependencies

In channels

main

Change contents

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

B:BD[3.36] → [2.0:1605]

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

[3.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,
    message: Message,
}
impl MessageHandler {
    pub fn new(implementation: Implementation, message: Message) -> Self {
        Self {
            implementation,
            message,
        }
    }
    pub fn handle(&self) {
        let _ = &(self.implementation)(&self.message);
    }
}
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 kind = msg.kind.clone();
        let json = msg.json.clone();
        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 c_kind = kind.clone();
            let c_json = json.clone();
            let c_handler = (*handler).clone();
            tokio::spawn(async move {
                let wrapper = MessageHandler::new(
                    c_handler,
                    Message {
                        kind: c_kind,
                        json: c_json,
                    },
                );
                wrapper.handle();
            });
        }
    }
}

Deletion in src/main.rs at line 1 [4.49]
B:BD[4.49] → [2.1606:1637]
```
use mediator::Implementation;
```
Deletion in src/main.rs at line 7 [4.49]
B:BD[2.1713] → [2.1713:1753]
∅:D[5.1236] → [6.941:942]
∅:D[2.1753] → [6.941:942]
B:BD[6.941] → [6.941:942]
```
    let mut mediator = Mediator::new();
```

Replacement in src/main.rs at line 8 [4.49]

B:BD[2.1794] → [2.1794:1912]

        let printer_1: Implementation = message_handler_1;
        let printer_2: Implementation = message_handler_2;

[2.1794]

[6.1058]

        let mut mediator = Mediator::new();

Replacement in src/main.rs at line 10 [4.49]

B:BD[6.1059] → [2.1913:2027]

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

[6.1059]

[6.1083]

        mediator.add(String::from("TEST-3"), message_handler_1);
        mediator.add(String::from("TEST-7"), message_handler_2);
        mediator.add(String::from("TEST-3"), message_handler_7);

Replacement in src/main.rs at line 25 [4.49]
B:BD[2.2257] → [2.2257:2303]
```
        Ok(_) => println!("SERVER STOPPED."),
```
[2.2257]
[2.2303]
```
        Ok(_) => {}
```

Insertion in src/main.rs at line 37 [4.49]

[6.1370]


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