auto-registry 0.0.1

Automatic registration using proc macros
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

# auto-registry -- Automatic registration via proc-macros

`auto-registry` is a crate that lets you automatically collect types inside a structure to later call a macro on them.
The main goal of this macro is to allow painless automatic registration by constructing the registered types on demand.

This crate uses the `proc_macros_span` span, thus requiring a nightly compiler.

# auto-registry in action

Basic example use of `auto-registry`:
```rust
pub trait Listener { ... }

#[auto_registry::auto_registry(registry = "listeners")]
pub struct KeyboardListener { ... }
impl Listener for KeyboardListener { ... }

#[auto_registry::auto_registry(registry = "listeners")]
pub struct MouseListener { ... }
impl Listener for MouseListener { ... }

macro_rules! collect_listeners { // Collects to a Vec<Box<dyn Listener>>
	( $($construct:expr);+ $(;)? ) => {{ // Macro must accepts `;`-separated arguments
		vec![$(Box::new($construct) as Box<dyn crate::Listener + Send + Sync>,)+]
	}};
}

/// Calling the `get_listeners!()` will generate the Vec containing all our listeners.
#[auto_registry::generate_registry(
    registry = "listeners",
    collector = collect_listeners,
    output = get_listeners)]
```

In this example, all registered types are mapped to expressions for the `collect_listeners` macro using `::default()`.

You can also specify how each types gets mapped to an expression via the `mapper` attribute:
```rust
pub trait Listener { ... }

#[auto_registry::auto_registry(registry = "listeners")]
pub struct KeyboardListener { ... }
impl Listener for KeyboardListener { ... }

#[auto_registry::auto_registry(registry = "listeners")]
pub struct MouseListener { ... }
impl Listener for MouseListener { ... }

macro_rules! map_listeners { // Maps a type to an expression
	($t:ty) => {{
        Box::new(<$t>::new()) as Box<dyn Listener + Send + Sync>
	}};
}

macro_rules! collect_listeners { // Collects to a Vec<Box<dyn Listener>>
	( $($construct:expr);+ $(;)? ) => {{ // Macro must accepts `;`-separated arguments
		vec![$($construct,)+]
	}};
}

/// Calling the `get_listeners!()` will generate the Vec containing all our listeners.
#[auto_registry::generate_registry(
    registry = "listeners",
    mapper = map_listeners,
    collector = collect_listeners,
    output = get_listeners)]
```

# License

This crate is licensed under the MIT license.