rusty-tracks 0.0.7

Rust client to connect to DataTracks.
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

use track_rails::message_generated::protocol;
use track_rails::message_generated::protocol::{Message, Payload};

pub struct CreatePlan{
    pub id: usize
}

impl TryFrom<Message<'_>> for CreatePlan {
    type Error = String;

    fn try_from(msg: Message) -> Result<Self, Self::Error> {
        match msg.data_type() {
            Payload::CreatePlanResponse => {
                Ok(CreatePlan { id: msg.data_as_create_plan_response().ok_or(String::from("Did not contain id."))?.id() as usize })
            },
            e => Err(format!("Wrong datatype {:?}", e))
        }

    }
}

pub struct DeletePlan{}
impl TryFrom<Message<'_>>
for DeletePlan {
    type Error = String;
    fn try_from(msg: Message) -> Result<Self, Self::Error> {
        match msg.data_type() {
            Payload::DeletePlanResponse => {
                Ok(DeletePlan { })
            }
            e => Err(format!("Wrong datatype {:?}", e))
        }
    }
}

pub struct Plans (pub(crate) Vec<Plan>);


pub struct Plan {
    pub id: usize,
}

impl TryFrom<protocol::Plan<'_>> for Plan {
    type Error = String;

    fn try_from(initial: protocol::Plan) -> Result<Self, Self::Error> {
        let id = initial.id() as usize;
        Ok(Plan { id })
    }
}

impl TryFrom<Message<'_>> for Plans {
    type Error = String;

    fn try_from(msg: Message<'_>) -> Result<Self, Self::Error> {
        match msg.data_type() {
            Payload::Catalog => {
                msg.data_as_catalog().map(|c| {
                    let plans = match c.plans() {
                        Some(plans) => plans,
                        None => return Err(String::from("Contains no plans.")),
                    };
                    match Plans::try_from(plans) {
                        Ok(plan) => Ok(plan),
                        Err(err) => return Err(err)
                    }
                }).ok_or(String::from("Plans is empty"))?
            }
            e => Err(format!("Wrong datatype {:?}", e))
        }
    }
}

impl TryFrom<protocol::Plans<'_>> for Plans {
    type Error = String;

    fn try_from(initial: protocol::Plans<'_>) -> Result<Self, Self::Error> {
        let mut plans = vec![];
        for plan in initial.plans() {
            plans.push(Plan::try_from(plan)?)
        }
        Ok(Plans(plans))
    }
}

pub struct StartPlan {
    already_running: bool,
}

impl TryFrom<Message<'_>> for StartPlan {
    type Error = String;

    fn try_from(msg: Message<'_>) -> Result<Self, Self::Error> {
        match msg.data_type() {
            Payload::StartPlanResponse => {
                let already_running = msg.data_as_start_plan_response().ok_or(String::from("Did not contain start."))?.already_running();
                Ok(StartPlan { already_running })
            },
            err => Err(String::from(format!("Wrong datatype {:?}", err)))
        }
    }
}

pub struct StopPlan {
    already_stopped: bool
}

impl TryFrom<Message<'_>> for StopPlan {
    type Error = String;
    fn try_from(msg: Message<'_>) -> Result<Self, Self::Error> {
        match msg.data_type() {
            Payload::StopPlanResponse => {
                let already_stopped = msg.data_as_stop_plan_response().ok_or(String::from("Did not contain start."))?.already_stopped();
                Ok(StopPlan { already_stopped })
            },
            err => Err(String::from(format!("Wrong datatype {:?}", err)))
        }
    }
}