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

use context::Context;
use message::MessageFuture;


#[doc(hidden)]
pub trait ActixActor {}

#[allow(unused_variables)]
pub trait Actor: Sized + 'static {

    /// Method is called when actor get polled first time.
    fn start(&mut self, ctx: &mut Context<Self>) {}

    /// Method is called when context's stream finishes.
    /// By default returns `ActorStatus::Done`.
    fn finished(&mut self, ctx: &mut Context<Self>) {}
}

/// Service is Actor
impl<T> ActixActor for T where T: Actor {}


pub trait Message: Sized + 'static {

    /// The type of value that this message will resolved with if it is successful.
    type Item;

    /// The type of error that this message will resolve with if it fails in a normal fashion.
    type Error;

}

#[allow(unused_variables)]
pub trait MessageHandler<M> where Self: Actor
{
    /// The type of value that this message will resolved with if it is successful.
    type Item;

    /// The type of error that this message will resolve with if it fails in a normal fashion.
    type Error;

    /// If message handler is used for handling messages from Future or Stream, then
    /// `InputError` type has to be set to correspondent `Error`
    type InputError;

    /// Method is called on error.
    fn error(&mut self, err: Self::InputError, ctx: &mut Context<Self>) {}

    /// Method is called for every message received by this Actor
    fn handle(&mut self, msg: M, ctx: &mut Context<Self>) -> MessageFuture<Self, M>;
}

#[allow(unused_variables)]
pub trait StreamHandler<M>: MessageHandler<M>
    where Self: Actor
{
    /// Method is called when service get polled first time.
    fn start(&mut self, ctx: &mut Context<Self>) {}

    /// Method is called when stream finishes.
    fn finished(&mut self, ctx: &mut Context<Self>) {}

}