dec/

dec.rs

use simple_sbe::decode::{decode_header, decode_message};
use simple_sbe::otf::header::MessageHeaderListener;
use simple_sbe::otf::listener::{TokenListener, TokenListenerError};
use simple_sbe::token::{
    ByteOrder, Encoding, Presence, PrimitiveType, PrimitiveValue, Signal, Token,
};
use simple_sbe::tokenize;
use std::borrow::Cow;
use std::collections::VecDeque;
use std::env::args;
use std::fs::File;
use std::io::Read;

fn main() -> anyhow::Result<()> {
    let args = args().skip(1).take(2).collect::<Vec<_>>();
    let mut schema_file = File::open(&args[0])?;
    let mut message_file = File::open(&args[1])?;

    let mut svbuf = Vec::new();
    schema_file.read_to_end(&mut svbuf)?;

    let mut msg_buf = Vec::new();
    message_file.read_to_end(&mut msg_buf)?;

    let tokens = tokenize(&svbuf);

    for t in &tokens {
        println!("{t:?}");
    }

    let mut l = MyListener::default();
    // let mut it = tokens.into_iter();
    println!("=== header ===");
    let mut x = MessageHeaderListener::new(&mut l);
    let (tokens, msg_buf) = decode_header(&tokens, &msg_buf, 0, &mut x);
    let h = x.into_message_header()?;
    println!("{h:?}");
    println!("=== message ===");
    let msg_buf = decode_message(&tokens, msg_buf, h.block_length, h.version as i32, &mut l);

    Ok(())
}

#[derive(Default)]
struct MyListener {
    named_scope: VecDeque<String>,
    composite_level: usize,
}

impl TokenListener for MyListener {
    fn on_begin_message(&mut self, token: &Token) -> Result<(), TokenListenerError> {
        self.named_scope.push_back(format!("{}", token.name));
        Ok(())
    }

    fn on_end_message(&mut self, token: &Token) -> Result<(), TokenListenerError> {
        self.named_scope.pop_back();
        Ok(())
    }

    fn on_encoding(
        &mut self,
        field_token: &Token,
        buffer: &[u8],
        type_token: &Token,
        acting_version: i32,
    ) -> Result<(), TokenListenerError> {
        // println!("    {name}: {{{}}} {p:?} = {buffer:02X?}", p.to_string());
        self.print_scope();
        if self.composite_level > 0 {
            print!("{}", type_token.name);
        } else {
            print!("{}", field_token.name);
        }

        let np = self.const_or_not_present_value(type_token, field_token.version, acting_version);
        if np.is_none() {
            println!(
                "={} : {buffer:02X?}",
                buffer
                    .chunks(type_token.encoding.primitive_type.size())
                    .map(|b| format!(
                        "{}",
                        PrimitiveValue::new(type_token.encoding.primitive_type, b)
                    ))
                    .collect::<Vec<_>>()
                    .join(", ")
            );
        } else {
            print!("={np}");
            for _ in 1..type_token.array_length() {
                print!(", {np}");
            }
            println!(" [const]")
        }

        Ok(())
    }

    fn on_enum(
        &mut self,
        field_token: &Token,
        enum_token: &Token,
        buffer: &[u8],
        tokens: &[Token],
        acting_version: i32,
    ) -> Result<(), TokenListenerError> {
        // println!("begin enum {field_token:?}");
        // println!("      enum {enum_token:?}");
        // println!(
        //     "~~> ENUM {:?}",
        //     tokens
        //         .iter()
        //         .map(|x| (&x.signal, &x.name))
        //         .collect::<Vec<_>>()
        // );
        let value = PrimitiveValue::new(enum_token.encoding.primitive_type, buffer);
        let mut name: Cow<str> = "???".into();
        if matches!(field_token.encoding.presence, Presence::Constant) {
            name = field_token.encoding.const_value.to_string()[enum_token.name.len() + 1..]
                .to_string()
                .into();
        } else {
            for t in tokens {
                // println!("{value:?} <> {:?} | {t:?}", t.encoding.const_value);
                if value == t.encoding.const_value {
                    name = (&t.name).into();
                    break;
                }
            }
        }
        self.print_scope();
        if self.composite_level > 0 {
            print!("{}=", enum_token.name);
        } else {
            print!("{}=", field_token.name);
        }
        println!("{name} : {value:?}");

        Ok(())
    }

    fn on_bit_set(
        &mut self,
        field_token: &Token,
        set_token: &Token,
        buffer: &[u8],
        tokens: &[Token],
        acting_version: i32,
    ) -> Result<(), TokenListenerError> {
        self.print_scope();
        if self.composite_level > 0 {
            print!("{}:", set_token.name);
        } else {
            print!("{}:", field_token.name);
        }
        let value: u64 = PrimitiveValue::new(set_token.encoding.primitive_type, buffer)
            .try_into()
            .unwrap();
        for t in tokens {
            let pos: u64 = (&t.encoding.const_value).try_into().unwrap();
            let is_set = (1 << pos & value) != 0;
            print!(" {}={is_set}", t.name);
        }
        println!();
        //todo!()
        Ok(())
    }

    fn on_begin_composite(
        &mut self,
        field_token: &Token,
        composite_token: &Token,
        tokens: &[Token],
    ) -> Result<(), TokenListenerError> {
        let name = if self.composite_level > 0 {
            &composite_token.name
        } else {
            &field_token.name
        };
        self.named_scope.push_back(name.to_owned());
        self.composite_level += 1;
        // self.named_scope.push_back(format!("{}", field_token.name)); //TODO
        Ok(())
    }

    fn on_end_composite(
        &mut self,
        field_token: &Token,
        tokens: &[Token],
    ) -> Result<(), TokenListenerError> {
        self.composite_level -= 1;
        let c = self.named_scope.pop_back();
        println!("-<- Composite {c:?}");
        debug_assert!(c.is_some());
        Ok(())
    }

    fn on_group_header(
        &mut self,
        token: &Token,
        num_in_group: usize,
    ) -> Result<(), TokenListenerError> {
        self.print_scope();
        println!("{} Group Header : numInGroup={num_in_group}", token.name);
        Ok(())
    }

    fn on_begin_group(
        &mut self,
        token: &Token,
        group_index: usize,
        num_in_group: usize,
    ) -> Result<(), TokenListenerError> {
        self.named_scope.push_back(format!("{}", token.name));
        Ok(())
    }

    fn on_end_group(
        &mut self,
        token: &Token,
        group_index: i32,
        num_in_group: i32,
    ) -> Result<(), TokenListenerError> {
        self.named_scope.pop_back();
        Ok(())
    }

    fn on_var_data(
        &mut self,
        field_token: &Token,
        buffer: &[u8],
        type_token: &Token,
    ) -> Result<(), TokenListenerError> {
        println!("VARDATA! {type_token:?}");
        self.print_scope();
        println!("{}='{:?}'", field_token.name, buffer);
        // todo!()
        Ok(())
    }
}

impl MyListener {
    fn print_scope(&self) {
        for s in &self.named_scope {
            print!("{s}.");
        }
    }

    fn const_or_not_present_value<'t>(
        &self,
        type_token: &'t Token,
        field_version: i32,
        acting_version: i32,
    ) -> &'t PrimitiveValue {
        match &type_token.encoding.presence {
            Presence::Constant => &type_token.encoding.const_value,
            Presence::Optional if acting_version < field_version => {
                type_token.encoding.applicable_null_value()
            }
            _ => &PrimitiveValue::None,
        }
    }

    fn encoding_as_string(
        &self,
        type_token: &Token,
        buffer: &[u8],
        field_version: i32,
        acting_version: i32,
    ) {
        let v = self.const_or_not_present_value(type_token, field_version, acting_version);
        if v.is_none() {}
    }
}