rusted_pipe 0.0.2

Real time processing library for developing multithreaded ML pipelines, written in Rust.
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

use crate::packet::Packet;
use paste::item;

pub trait PacketSetTrait {}

macro_rules! typed_packet {
    ($struct_name:ident, $($T:ident),+) => {
        #[allow(non_camel_case_types)]
        pub struct $struct_name<$($T: Clone),+> {
            $(
                $T : Option<Packet<$T>>,
            )+
        }

        #[allow(non_camel_case_types)]
        impl<$($T: Clone),+> PacketSetTrait for $struct_name<$($T),+>  {}

        #[allow(non_camel_case_types)]
        unsafe impl<$($T: Clone),+> Send for $struct_name<$($T),+>  {}

        item! {
            #[allow(non_camel_case_types)]
            pub enum [<$struct_name Channels>] {
                $(
                    $T,
                )+
            }
        }


        #[allow(non_camel_case_types)]
        impl<$($T: Clone),+> $struct_name<$($T),+> {
            pub fn new($($T: Option<Packet<$T>>,)+) -> Self {
                Self {
                    $(
                        $T,
                    )+
                }
            }

            pub fn create() -> Self {
                Self {
                    $(
                        $T: Option::<Packet<$T>>::None,
                    )+
                }
            }

            $(
                pub fn $T(&self) -> Option<&Packet<$T>> {
                    if let Some(data) = self.$T.as_ref() {
                        return Some(&data);
                    }
                    None
                }
            )+

            item! {
                $(
                    pub fn [<$T _ owned>](&mut self) -> Option<Packet<$T>> {
                        if let Some(_) = self.$T {
                            return self.$T.take();
                        }
                        None
                    }
                )+
            }

            item! {
                $(
                    pub fn [<set _ $T>](&mut self, data: Option<Packet<$T>>) {
                        self.$T = data;
                    }
                )+
            }

            pub fn values(&self) -> ($(Option<&Packet<$T>>,)+) {
               (
                    $(
                        self.$T.as_ref(),
                    )+
               )
            }

            pub fn has_none(&self) -> bool {
                let values = vec![ $(
                    self.$T.is_some(),
                )+ ];
                values.iter().all(|v| *v)
            }
        }
    };
}

typed_packet!(ReadChannel1PacketSet, c1);
typed_packet!(ReadChannel2PacketSet, c1, c2);
typed_packet!(ReadChannel3PacketSet, c1, c2, c3);
typed_packet!(ReadChannel4PacketSet, c1, c2, c3, c4);
typed_packet!(ReadChannel5PacketSet, c1, c2, c3, c4, c5);
typed_packet!(ReadChannel6PacketSet, c1, c2, c3, c4, c5, c6);
typed_packet!(ReadChannel7PacketSet, c1, c2, c3, c4, c5, c6, c7);
typed_packet!(ReadChannel8PacketSet, c1, c2, c3, c4, c5, c6, c7, c8);