tosca 0.1.1

A library that acts as an interface between a device and its controller.
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
133
134
135
136
137
138
139
140
141

macro_rules! mandatory_route {
    (
        $name:ident,
        $path:expr,
        methods: [$($method:ident),* $(,)?]
    ) => {
        #[doc = concat!("A mandatory [`", stringify!($name), "`].")]
        #[derive(Debug)]
        pub struct $name {
            route: Route,
        }

        impl $name {
            $(
                mandatory_route!(@method_fn $method, $name, $path);
            )*

            #[doc = "Sets the route description."]
            #[must_use]
            pub fn description(mut self, description: &'static str) -> Self {
                self.route = self.route.description(description);
                self
            }

            #[doc = "Changes the route name."]
            #[must_use]
            pub fn change_name(mut self, name: &'static str) -> Self {
                self.route = self.route.change_name(name);
                self
            }

            #[doc = concat!("Adds [`Hazards`] to a [`", stringify!($name), "`].")]
            #[must_use]
            #[inline]
            pub fn with_hazards(mut self, hazards: Hazards) -> Self {
                self.route = self.route.with_hazards(hazards);
                self
            }

            #[doc = concat!("Adds an [`Hazard`] to a [`", stringify!($name), "`].")]
            #[must_use]
            #[inline]
            pub fn with_hazard(mut self, hazard: Hazard) -> Self {
                self.route = self.route.with_hazard(hazard);
                self
            }

            #[doc = concat!("Adds an array of [`Hazard`]s to a [`", stringify!($name), "`].")]
            #[must_use]
            #[inline]
            pub fn with_array_of_hazards<const N: usize>(mut self, hazards: [Hazard; N]) -> Self {
                self.route = self.route.with_array_of_hazards(hazards);
                self
            }

            #[doc = concat!("Adds [`Parameters`] to a [`", stringify!($name), "`].")]
            #[must_use]
            #[inline]
            pub fn with_parameters(mut self, parameters: Parameters) -> Self {
                self.route = self.route.with_parameters(parameters);
                self
            }

            #[doc = "Returns the route path."]
            #[must_use]
            pub fn route(&self ) -> &str {
                self.route.route()
            }

            #[doc = concat!("Returns the [`RestKind`].")]
            #[must_use]
            pub const fn kind(&self) -> RestKind {
                self.route.kind()
            }

            #[doc = concat!("Returns all route [`Hazards`].")]
            #[must_use]
            pub const fn hazards(&self) -> &Hazards {
               self.route.hazards()
            }

            #[doc = concat!("Returns all route [`Parameters`].")]
            #[must_use]
            pub const fn parameters(&self) -> &Parameters {
                self.route.parameters()
            }

            #[doc = "Returns the internal [`Route`]."]
            #[must_use]
            pub fn into_route(self) -> Route {
                self.route
            }
        }
    };

    (@method_fn get, $name:ident, $path:expr) => {
        #[doc = concat!("Creates a [`", stringify!($name), "`] through a `GET` API.")]
        #[must_use]
        #[inline]
        pub fn get(name: &'static str) -> Self {
            Self {
                route: Route::get(name, $path),
            }
        }
    };

    (@method_fn put, $name:ident, $path:expr) => {
        #[doc = concat!("Creates a [`", stringify!($name), "`] through a `PUT` API.")]
        #[must_use]
        #[inline]
        pub fn put(name: &'static str) -> Self {
            Self {
                route: Route::put(name, $path),
            }
        }
    };

    (@method_fn post, $name:ident, $path:expr) => {
        #[doc = concat!("Creates a [`", stringify!($name), "`] through a `POST` API.")]
        #[must_use]
        #[inline]
        pub fn post(name: &'static str) -> Self {
            Self {
                route: Route::post(name, $path),
            }
        }
    };

    (@method_fn delete, $name:ident, $path:expr) => {
        #[doc = concat!("Creates a [`", stringify!($name), "`] through a `DELETE` API.")]
        #[must_use]
        #[inline]
        pub fn delete(name: &'static str) -> Self {
            Self {
                route: Route::delete(name, $path),
            }
        }
    };
}

pub(crate) use mandatory_route;