Attribute Macro observer 

#[observer]

Implements the event(&mut self) & as_any(&self) methodes to applied trait and generate Observer struct to use observer pattern.

Supported Attributes:

• publisher_name = "name" = change the name of the generated publisher struct to spesific value.

Generates

(for trait MyTrait)

trait MyTrait{
    ...
    fn event(&mut self);
    fn as_any(&self) -> &dyn Any;
}

struct MyTraitObserver{
    observers: Vec<Box<dyn MyTrait>>
}

impl MyTraitObserver{
    fn new() -> MyTraitObserver {...}
    fn get_observer_ptr(observer: &Box<dyn MyTrait>) -> *const dyn MyTrait {...}

    fn subscribe(&mut self, val: Box<dyn MyTrait>) {...}
    fn unsubscribe(&mut self, target: *const dyn MyTrait) {...}
    fn notify(&mut self) {...}
}

Example

use patternutils::observer;

#[observer(publisher_name = "ItemPublisher")]
trait ItemObserver {
    fn get_code(&self) -> usize;
}

struct Item {
    code: usize
}

impl ItemObserver for Item {
    fn get_code(&self) -> usize {
        self.code
    }

    fn event(&mut self) {
        println!("[{}] Event!", self.code);
    }

    fn as_any(&self) ->  &dyn Any {
        self
    }
}

fn main() {
    let mut last_ptr = None;
    let mut publisher = ItemPublisher::new();

    for i in 0..10{
        let boxed_item: Box<dyn ItemObserver> = Box::new(Item {code: i});
        last_ptr = Some(ItemPublisher::get_observer_ptr(&boxed_item));
        publisher.subscribe(boxed_item);            //Add instance to observers
    }
     
    println!("Every item:");
    publisher.notify();                             //Notify all instances
     
    println!("\nEvery item without the last one:");

    publisher.unsubscribe(last_ptr.unwrap());       //Remove last added instance
    publisher.notify();                             //Notify all instances
}