Macro covalent::lock_data

macro_rules! lock_data {
    ($struct_name:ident $($name:ident : $mutability:ident $data_type:ty),+) => { ... };
    (@ generate parameter read $data_type:ty) => { ... };
    (@ generate parameter write $data_type:ty) => { ... };
    (@ generate parameter $mutability:ident $data_type:ty) => { ... };
    (@ generate locks $s:ident, $f:ident, $e:ident,
        $name0:ident, $mutability0:ident, $data_type0: ty | $($mutability1:ident)* | $($guard1:ident)*
        ) => { ... };
    (@ generate locks $s:ident, $f:ident, $e:ident,
        $name0:ident, $mutability0:ident, $data_type0: ty
        ) => { ... };
    (@ generate locks $s:ident, $f:ident, $e:ident,
        $name0:ident, $mutability0:ident, $data_type0: ty,
        $($tail:tt)* | $($mutability1:ident),* | $($guard1:ident),*
        ) => { ... };
    (@ generate locks $s:ident, $f:ident, $e:ident,
        $name0:ident, $mutability0:ident, $data_type0: ty,
        $($tail:tt)*
        ) => { ... };
    (@ generate mutability read $thing:ident) => { ... };
    (@ generate mutability write $thing:ident) => { ... };
    (@ generate mutability read &$thing:ident) => { ... };
    (@ generate mutability write &$thing:ident) => { ... };
    (@ generate try mutability read $rwlock:ident) => { ... };
    (@ generate try mutability write $rwlock:ident) => { ... };
}

A macro to generate a struct containing a list of fields that may be locked. This allows for more intuitive concurrency, by abstracting away the lock-unlock logic and potential lock mishaps.

Examples

struct HelloWorldObject {
    message: &'static str
}

struct Output {
    message: Option<&'static str>
}

use covalent::lock_data;
use covalent::events::{Event, EventHandler};
lock_data! {
    HelloWorldData

    hello_world: read HelloWorldObject,
    output: write Output
}

fn create_locks() {
    use std::sync::*;
    use covalent::scene::{Event, EventHandler};

    let hello_world = Arc::new(RwLock::new(HelloWorldObject { message: "Hello, world!" }));
    let output = Arc::new(RwLock::new(Output { message: None }));

    let data = Arc::new(RwLock::new(HelloWorldData {
        hello_world: Arc::downgrade(&hello_world),
        output: Arc::downgrade(&output)
    }));

    struct HelloWorldEvent {}
    impl Event for HelloWorldEvent {}
    let event_handler = Arc::new(RwLock::new(EventHandler::<HelloWorldEvent>::new()));

    HelloWorldData::listen(&data, &event_handler, |event, hello_world, output| {
        output.message = Some(hello_world.message);
    });
}