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

use anyhow::Result;

use crate::stream::{InputStreams, OutputStreams, StreamType, Streamp};
use crate::Error;

pub fn get_input<T>(r: &InputStreams, n: usize) -> Streamp<T>
where
    T: Copy,
    Streamp<T>: From<StreamType>,
{
    let ret: Streamp<T> = r.get(n).into();
    ret
}

pub fn get_output<T>(w: &mut OutputStreams, n: usize) -> Streamp<T>
where
    T: Copy,
    Streamp<T>: From<StreamType>,
{
    let output: Streamp<T> = w.get(n).into();
    output
}

pub enum BlockRet {
    Ok,
    EOF,
}

pub trait Block {
    fn block_name(&self) -> &'static str;
    fn work(&mut self, r: &mut InputStreams, w: &mut OutputStreams) -> Result<BlockRet, Error>;
}

#[macro_export]
macro_rules! map_block_macro_v2 {
    ($name:path, $($tr:path), *) => {
        impl<T> Block for $name
        where
            T: Copy $(+$tr)*,
            Streamp<T>: From<StreamType>,
        {
            fn block_name(&self) -> &'static str {
                stringify!{$name}
            }
            fn work(
                &mut self,
                r: &mut InputStreams,
                w: &mut OutputStreams,
            ) -> Result<BlockRet, Error> {
                let i = get_input(r, 0);
                get_output(w, 0)
                    .borrow_mut()
                    .write(i
                           .borrow()
                           .iter()
                           .map(|x| self.process_one(x)));
                i.borrow_mut().clear();
                Ok(BlockRet::Ok)
            }
        }
    };
}

#[macro_export]
macro_rules! map_block_convert_macro {
    ($name:path) => {
        impl Block for $name {
            fn block_name(&self) -> &'static str {
                stringify! {$name}
            }
            fn work(
                &mut self,
                r: &mut InputStreams,
                w: &mut OutputStreams,
            ) -> Result<BlockRet, Error> {
                let i = get_input(r, 0);
                get_output(w, 0)
                    .borrow_mut()
                    .write(i.borrow().iter().map(|x| self.process_one(*x)));
                i.borrow_mut().clear();
                Ok(BlockRet::Ok)
            }
        }
    };
}