pictorus-blocks 0.0.0

Implementations of Pictorus blocks.
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

extern crate alloc;
use alloc::{
    string::{String, ToString},
    vec::Vec,
};
use pictorus_block_data::BlockData as OldBlockData;
use pictorus_traits::{ByteSliceSignal, PassBy, ProcessBlock};

/// Parameters for UDP Transmit Block
#[doc(hidden)]
pub struct Parameters {
    /// Destination address for the UDP socket
    /// e.g. "192.168.0.1:12345"
    destination: String,
}

impl Parameters {
    pub fn new(destination: &str) -> Self {
        Self {
            destination: destination.to_string(),
        }
    }

    /// Get the destination address for the UDP socket
    pub fn destination(&self) -> &str {
        &self.destination
    }
}

/// Buffers data to be sent to a UDP port.
///
/// This block sends data to a Hardware specific UDP `OutputBlock` that is added
/// by codegen
pub struct UdpTransmitBlock {
    pub data: OldBlockData,
    buffer: Vec<u8>,
}

impl Default for UdpTransmitBlock {
    fn default() -> Self {
        Self {
            data: OldBlockData::from_bytes(b""),
            buffer: Vec::new(),
        }
    }
}

impl ProcessBlock for UdpTransmitBlock {
    type Parameters = Parameters;
    type Inputs = ByteSliceSignal;
    type Output = ByteSliceSignal;

    fn process<'b>(
        &'b mut self,
        _parameters: &Self::Parameters,
        _context: &dyn pictorus_traits::Context,
        inputs: PassBy<'_, Self::Inputs>,
    ) -> PassBy<'b, Self::Output> {
        self.buffer.clear();
        self.buffer.extend_from_slice(inputs);
        self.data.set_bytes(&self.buffer);
        &self.buffer
    }
}