interthread 3.1.0

Auto implementation of the Actor Model
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


use interthread::actor as life;


#[test]
fn static_methods_generic_model() {

    struct Actor <T> { field: T }

    #[life]
    impl <T> Actor <T>
    where 
    T: ToString 
    {
        pub fn new( field: T) -> Self { Self{ field } }

        pub fn set_field(&mut self, val: T ){ self.field = val; }

        pub fn stat_method_io( val:u8) -> u16 { (val*2) as u16 }

        pub fn stat_method_i( _val:u8) {}

        pub fn stat_method_o( ) -> u16 { 144u16 }

        pub fn stat_method_none( ) {}
        
        pub fn generic_static<S:ToString>( s:S) -> String {
            s.to_string()
        }
    }

    let mut act = ActorLive::new(String::from("a"));
    
    let var = ActorLive::<String>::generic_static(1);
    act.set_field(var);

    assert_eq!(ActorLive::<String>::stat_method_io(3), 6u16 );
    assert_eq!(ActorLive::<String>::stat_method_i(3), () );
    assert_eq!(ActorLive::<String>::stat_method_o(), 144u16 );
    assert_eq!(ActorLive::<String>::stat_method_none(),());

    // if generic, the model becomes inflexible ((( 

}



#[test]
fn static_methods_async() {

    struct Actor;

    #[life(lib="tokio")]
    impl Actor {
        pub fn new() -> Self { Self }

        pub async fn stat_method_io( val:u8) -> u16 { (val*2) as u16 }

        pub async fn stat_method_i( _val:u8) {}

        pub async fn stat_method_o( ) -> u16 { 144u16 }

        pub async fn stat_method_none( ) {}
        
        pub async fn generic_static<S:ToString>( s:S) -> String {
            s.to_string()
        }
    }

    tokio::runtime::Runtime::new()
    .unwrap()
    .block_on(async {
        let _ = ActorLive::new();
        assert_eq!(ActorLive::stat_method_io(3).await, 6u16 );
        assert_eq!(ActorLive::stat_method_i(3).await, () );
        assert_eq!(ActorLive::stat_method_o().await, 144u16 );
        assert_eq!(ActorLive::stat_method_none().await,());
        assert_eq!(ActorLive::generic_static(1).await, 1.to_string());
    });
    
}