kay_codegen 0.3.10

Code generation for implementing kay actors
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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

//! This is all auto-generated. Do not touch.
#![rustfmt::skip]
#[allow(unused_imports)]
use kay::{ActorSystem, TypedID, RawID, Fate, Actor, TraitIDFrom, ActorOrActorTrait};
#[allow(unused_imports)]
use super::*;



impl Actor for SomeActor {
    type ID = SomeActorID;

    fn id(&self) -> Self::ID {
        self.id
    }
    unsafe fn set_id(&mut self, id: RawID) {
        self.id = Self::ID::from_raw(id);
    }
}


pub struct SomeActorID {
    _raw_id: RawID
}

impl Copy for SomeActorID {}
impl Clone for SomeActorID { fn clone(&self) -> Self { *self } }
impl ::std::fmt::Debug for SomeActorID {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "SomeActorID({:?})", self._raw_id)
    }
}
impl ::std::hash::Hash for SomeActorID {
    fn hash<H: ::std::hash::Hasher>(&self, state: &mut H) {
        self._raw_id.hash(state);
    }
}
impl PartialEq for SomeActorID {
    fn eq(&self, other: &SomeActorID) -> bool {
        self._raw_id == other._raw_id
    }
}
impl Eq for SomeActorID {}

impl TypedID for SomeActorID {
    type Target = SomeActor;

    fn from_raw(id: RawID) -> Self {
        SomeActorID { _raw_id: id }
    }

    fn as_raw(&self) -> RawID {
        self._raw_id
    }
}

impl SomeActorID {
    pub fn some_method(self, some_param: usize, world: &mut World) {
        world.send(self.as_raw(), MSG_SomeActor_some_method(some_param));
    }

    pub fn no_params_fate(self, world: &mut World) {
        world.send(self.as_raw(), MSG_SomeActor_no_params_fate());
    }

    pub fn init_ish(some_param: usize, world: &mut World) -> Self {
        let id = SomeActorID::from_raw(world.allocate_instance_id::<SomeActor>());
        let swarm = world.local_broadcast::<SomeActor>();
        world.send(swarm, MSG_SomeActor_init_ish(id, some_param));
        id
    }
}

#[derive(Compact, Clone)] #[allow(non_camel_case_types)]
struct MSG_SomeActor_some_method(pub usize);
#[derive(Copy, Clone)] #[allow(non_camel_case_types)]
struct MSG_SomeActor_no_params_fate();
#[derive(Compact, Clone)] #[allow(non_camel_case_types)]
struct MSG_SomeActor_init_ish(pub SomeActorID, pub usize);


#[allow(unused_variables)]
#[allow(unused_mut)]
pub fn auto_setup(system: &mut ActorSystem) {


    system.add_handler::<SomeActor, _, _>(
        |&MSG_SomeActor_some_method(some_param), instance, world| {
            instance.some_method(some_param, world); Fate::Live
        }, false
    );

    system.add_handler::<SomeActor, _, _>(
        |&MSG_SomeActor_no_params_fate(), instance, world| {
            instance.no_params_fate(world)
        }, false
    );

    system.add_spawner::<SomeActor, _, _>(
        |&MSG_SomeActor_init_ish(id, some_param), world| {
            SomeActor::init_ish(id, some_param, world)
        }, false
    );
}