[−][src]Trait dyn_context::Context

pub trait Context {
    fn get_raw(&self, ty: TypeId) -> Option<&dyn Any>;

    fn get_mut_raw(&mut self, ty: TypeId) -> Option<&mut dyn Any>;
}

A service provider pattern implementation.

Useful for building complex systems with callbacks without generic parameters.

Examples

mod call_back {
    use dyn_context::Context;

    pub struct CallBack {
        callback: Option<fn(context: &mut dyn Context)>
    }

    impl CallBack {
        pub fn new() -> Self { CallBack { callback: None } }

        pub fn set_callback(&mut self, callback: fn(context: &mut dyn Context)) {
            self.callback.replace(callback);
        }

        pub fn call_back(&self, context: &mut dyn Context) {
            self.callback.map(|callback| callback(context));
        }
    }
}

use std::convert::Into;
use dyn_context::{TrivialContext, ContextExt};
use call_back::CallBack;

struct PrintContext {
    value: String
}

impl TrivialContext for PrintContext { }

let mut call_back = CallBack::new();
call_back.set_callback(|context| {
    let print: &PrintContext = context.get();
    println!("{}", &print.value);
});
call_back.call_back(&mut PrintContext { value: "Hello, world!".into() });

For using &str instead of String the context! macro can be used:

use dyn_context::{context, ContextExt};
use call_back::CallBack;

context! {
    mod print_value {
        value: ref str
    }
}

use print_value::Context as PrintValue;

context! {
    mod print_context {
        dyn value: ref PrintValue
    }
}

use print_context::Context as PrintContext;

let mut call_back = CallBack::new();
call_back.set_callback(|context| {
    let print_value: &PrintValue = context.get();
    println!("{}", print_value.value());
});
PrintValue::call("Hello, world!", |print_value| {
    PrintContext::call(print_value, |context| call_back.call_back(context));
});

Required methods

fn get_raw(&self, ty: TypeId) -> Option<&dyn Any>

fn get_mut_raw(&mut self, ty: TypeId) -> Option<&mut dyn Any>

Loading content...

Implementors

impl Context for ![src]

impl Context for ()[src]

impl Context for Context[src]

impl<T: TrivialContext> Context for T[src]

Loading content...