Struct futuresdr::blocks::Apply

pub struct Apply<A, B> where
    A: 'static,
    B: 'static, { /* private fields */ }

Applies a function to each sample in the stream.

Inputs

in: Input

Outputs

out: Output after function applied

Usage

use futuresdr::blocks::Apply;
use futuresdr::runtime::Flowgraph;
use num_complex::Complex;

let mut fg = Flowgraph::new();

// Double each sample
let doubler = fg.add_block(Apply::<f32, f32>::new(|i| i * 2.0));

// Note that the closure can also hold state
let mut last_value = 0.0;
let moving_average = fg.add_block(Apply::<f32, f32>::new(move |i| {
    let new_value = (last_value + i) / 2.0;
    last_value = *i;
    new_value
}));

// Additionally, the closure can change the type of the sample
let to_complex = fg.add_block(Apply::<f32, Complex<f32>>::new(|i| {
    Complex {
        re: 0.0,
        im: *i,
    }
}));

Implementations

impl<A, B> Apply<A, B> where
    A: 'static,
    B: 'static, 

pub fn new(f: impl FnMut(&A) -> B + Send + 'static) -> Block

Trait Implementations

impl<A, B> Kernel for Apply<A, B> where
    A: 'static,
    B: 'static, 

fn work<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>(
    &'life0 mut self,
    io: &'life1 mut WorkIo,
    sio: &'life2 mut StreamIo,
    _mio: &'life3 mut MessageIo<Self>,
    _meta: &'life4 mut BlockMeta
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    'life4: 'async_trait,
    Self: 'async_trait, 

fn init<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 mut self,
    _s: &'life1 mut StreamIo,
    _m: &'life2 mut MessageIo<Self>,
    _b: &'life3 mut BlockMeta
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait, 

fn deinit<'life0, 'life1, 'life2, 'life3, 'async_trait>(
    &'life0 mut self,
    _s: &'life1 mut StreamIo,
    _m: &'life2 mut MessageIo<Self>,
    _b: &'life3 mut BlockMeta
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    'life3: 'async_trait,
    Self: 'async_trait,