lunatic 0.14.1

Helper library for building Rust applications that run on lunatic.
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! All handlers that can be used inside of [`AbstractProcess::Handlers`] tuple.

use std::any::{type_name, TypeId};
use std::marker::PhantomData;

use super::messages::RequestMessage;
use super::{AbstractProcess, DeferredRequestHandler, MessageHandler, RequestHandler};
use crate::serializer::CanSerialize;
use crate::Tag;

pub struct Message<T>(PhantomData<T>);
pub struct Request<T>(PhantomData<T>);
pub struct DeferredRequest<T>(PhantomData<T>);

pub trait Handler<AP: AbstractProcess> {
    fn handle(response_tag: Tag, state: &mut AP::State);
}

impl<AP, T> Handler<AP> for Message<T>
where
    AP: MessageHandler<T>,
    AP::Serializer: CanSerialize<T>,
{
    fn handle(_: Tag, state: &mut <AP as AbstractProcess>::State) {
        let state = super::State { state };
        let message = AP::Serializer::decode().unwrap();
        AP::handle(state, message);
    }
}

impl<AP, T> Handler<AP> for Request<T>
where
    AP: RequestHandler<T>,
    AP::Serializer: CanSerialize<T>,
    AP::Serializer: CanSerialize<AP::Response>,
    AP::Serializer: CanSerialize<RequestMessage<T, AP::Response, AP::Serializer>>,
{
    fn handle(response_tag: Tag, state: &mut <AP as AbstractProcess>::State) {
        let state = super::State { state };
        let request: RequestMessage<T, AP::Response, AP::Serializer> =
            AP::Serializer::decode().unwrap();
        let response = AP::handle(state, request.0);
        request.1.send_response(response, response_tag);
    }
}

impl<AP, T> Handler<AP> for DeferredRequest<T>
where
    AP: DeferredRequestHandler<T>,
    AP::Serializer: CanSerialize<T>,
    AP::Serializer: CanSerialize<AP::Response>,
    AP::Serializer: CanSerialize<RequestMessage<T, AP::Response, AP::Serializer>>,
{
    fn handle(response_tag: Tag, state: &mut <AP as AbstractProcess>::State) {
        let state = super::State { state };
        let request: RequestMessage<T, AP::Response, AP::Serializer> =
            AP::Serializer::decode().unwrap();
        AP::handle(
            state,
            request.0,
            super::DeferredResponse {
                tag: response_tag,
                return_address: request.1,
            },
        );
    }
}

pub trait Handlers<AP: AbstractProcess> {
    fn handler_id<Handler: 'static>() -> u8;
    fn handle(response_tag: Tag, id: u8, state: &mut AP::State);
}

// Implement `Handlers` for tuple containing up to 16 handlers.
macros::impl_handlers!();
macros::impl_handlers!(T1 1);
macros::impl_handlers!(T1 1, T2 2);
macros::impl_handlers!(T1 1, T2 2, T3 3);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9, T10 10);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9, T10 10, T11 11);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9, T10 10, T11 11, T12 12);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9, T10 10, T11 11, T12 12, T13 13);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9, T10 10, T11 11, T12 12, T13 13, T14 14);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9, T10 10, T11 11, T12 12, T13 13, T14 14, T15 15);
macros::impl_handlers!(T1 1, T2 2, T3 3, T4 4, T5 5, T6 6, T7 7, T8 8, T9 9, T10 10, T11 11, T12 12, T13 13, T14 14, T15 15, T16 16);

mod macros {
    macro_rules! impl_handlers {
        ($($args:ident $i:tt),*) => {
            impl<AP, $($args: 'static),*> Handlers<AP> for ($($args,)*)
            where
                AP: AbstractProcess,
                $($args: Handler<AP>),*
            {
                #[track_caller]
                fn handler_id<Handler: 'static>() -> u8 {
                    match TypeId::of::<Handler>() {
                        $(id if id == TypeId::of::<$args>() => $i,)*
                        _ => panic!(
                            "Called `send/request()` on type '{}' that doesn't match any handler defined in '<{} as AbstractProcess>::Handlers'",
                            type_name::<Handler>(),
                            type_name::<AP>()
                        ),
                    }
                }

                #[allow(unused_variables)]
                fn handle(response_tag: Tag, id: u8, state: &mut <AP as AbstractProcess>::State) {
                    match id {
                        // Handlers start with a value of 1. Zero indicates that this is a response from another
                        // process where the call timed out, and we don't care about the result.
                        0 => (),
                        $($i => $args::handle(response_tag, state),)*
                        _ => unreachable!(
                            "AbstractProcess `{}` received message with unknown message ID: {}.",
                            type_name::<AP>(),
                            id
                        ),
                    }
                }
            }
        };
    }

    pub(crate) use impl_handlers;
}