simple_sbe/

decode.rs

use crate::otf::listener::TokenListener;
use crate::token::{PrimitiveValue, Signal, Token};

pub fn decode_header<'t, 'b, L>(
    tokens: &'t [Token],
    msg_buf: &'b [u8],
    acting_version: i32,
    listener: &mut L,
) -> (&'t [Token], &'b [u8])
where
    L: TokenListener,
{
    println!(" == decode {msg_buf:02X?}");
    let Some((tok, rest)) = tokens.split_first() else {
        return (&[], &[]); //TODO
    };
    let count = tok.component_token_count as usize;
    //TODO: actually check?
    let Some((composite, rest)) = rest.split_at_checked(count - 1) else {
        return (&[], &[]); //TODO
    };
    debug_assert_eq!(tok.signal, Signal::BeginComposite);
    debug_assert_eq!(composite.last().unwrap().signal, Signal::EndComposite);
    decode_composite(
        tok,
        &composite[0],
        &composite[..count - 2],
        msg_buf,
        acting_version,
        listener,
    );
    (rest, &msg_buf[tok.encoded_length as usize..])
}

pub fn decode_message<'t, 'b, L>(
    tokens: &'t [Token],
    msg_buf: &'b [u8],
    block_length: usize,
    acting_version: i32,
    listener: &mut L,
) -> &'b [u8]
where
    L: TokenListener,
{
    println!(" == decode {msg_buf:02X?}");
    let Some((tok, rest)) = tokens.split_first() else {
        return &[]; //TODO
    };
    //TODO: actually check?
    debug_assert_eq!(tok.signal, Signal::BeginMessage);
    listener.on_begin_message(tok).unwrap();

    let rest = decode_fields(rest, msg_buf, acting_version, listener);

    let end_tok = tokens.last().unwrap();
    debug_assert_eq!(end_tok.signal, Signal::EndMessage);

    decode_groups(rest, &msg_buf[block_length..], acting_version, listener);
    // decode_data(rest, &msg_buf[block_length..], acting_version, listener);

    listener.on_end_message(end_tok).unwrap();
    &[]
}

fn decode_groups<'t, 'b, L>(
    mut tokens: &'t [Token],
    mut msg_buf: &'b [u8],
    acting_version: i32,
    listener: &mut L,
) -> &'t [Token]
where
    L: TokenListener,
{
    println!(" == decode {msg_buf:02X?}");
    loop {
        let Some((
            [
                begin_tok,
                dimension_type_comp_tok,
                block_len_tok,
                num_in_group_tok,
                dimension_type_end_comp_tok,
            ],
            mut rest,
        )) = tokens.split_first_chunk()
        else {
            println!("no group? {:?}", tokens);
            break;
        };

        //TODO: actually check?
        debug_assert_eq!(begin_tok.signal, Signal::BeginGroup);
        debug_assert_eq!(dimension_type_comp_tok.signal, Signal::BeginComposite);
        debug_assert_eq!(block_len_tok.signal, Signal::Encoding);
        debug_assert_eq!(num_in_group_tok.signal, Signal::Encoding);
        debug_assert_eq!(dimension_type_end_comp_tok.signal, Signal::EndComposite);

        let is_present = begin_tok.version <= acting_version;
        let block_len = is_present
            .then_some(block_len_tok.offset as usize)
            .unwrap_or(0);
        let mut num_in_group: usize = 0;

        if is_present {
            let num: u64 = PrimitiveValue::new(
                num_in_group_tok.encoding.primitive_type,
                &msg_buf[num_in_group_tok.offset as usize
                    ..num_in_group_tok.offset as usize + num_in_group_tok.encoded_length as usize],
            )
            .try_into()
            .unwrap();
            num_in_group = num as usize;
            msg_buf = &msg_buf[dimension_type_comp_tok.encoded_length as usize..];
        }

        listener.on_group_header(begin_tok, num_in_group).unwrap();

        for i in 0..num_in_group {
            listener.on_begin_group(begin_tok, i, num_in_group).unwrap();

            rest = decode_fields(rest, msg_buf, acting_version, listener);

            //TODO: decode groups!!!

            decode_data(rest, &msg_buf[block_len..], acting_version, listener);
            // msg_buf = &msg_buf[block_len..];
            break; //TODO
        }
        break; //TODO
    }
    &[]
}

fn decode_data<'t, 'b, L>(
    mut tokens: &'t [Token],
    mut msg_buf: &'b [u8],
    acting_version: i32,
    listener: &mut L,
) -> &'t [Token]
where
    L: TokenListener,
{
    println!(" == decode {msg_buf:02X?}");
    loop {
        let Some(([begin_tok, comp_tok, len_tok, var_data_tok], rest)) = tokens.split_first_chunk()
        else {
            println!("no vardata? {:?}", tokens);
            break;
        };
        if begin_tok.signal != Signal::BeginVarData {
            println!(
                "not begin var data field {:?}@{}",
                begin_tok.signal, begin_tok.i
            );
            break;
        }
        debug_assert_eq!(comp_tok.signal, Signal::BeginComposite);
        debug_assert_eq!(len_tok.signal, Signal::Encoding);
        debug_assert_eq!(var_data_tok.signal, Signal::Encoding);
        let is_present = begin_tok.version <= acting_version;
        let len = is_present.then_some(len_tok.offset as usize).unwrap_or(0);
        let off = is_present
            .then_some(var_data_tok.offset as usize)
            .unwrap_or(0);
        listener
            .on_var_data(begin_tok, &msg_buf[off..off + len], var_data_tok)
            .unwrap();
        tokens = rest;
        msg_buf = &msg_buf[off + len..];
    }
    &[]
}

fn decode_fields<'t, 'b, L>(
    mut tokens: &'t [Token],
    msg_buf: &'b [u8],
    acting_version: i32,
    listener: &mut L,
) -> &'t [Token]
where
    L: TokenListener,
{
    loop {
        let Some(([field_tok, type_tok], rest)) = tokens.split_first_chunk() else {
            println!("finished tok?? {:?}", tokens);
            break;
        };
        if field_tok.signal != Signal::BeginField {
            println!("not begin field {:?}@{}", field_tok.signal, field_tok.i);
            break;
        }

        let type_token_count = type_tok.component_token_count as usize;
        let Some((current, next)) = rest.split_at_checked(type_token_count) else {
            println!("can't split next field");
            break;
        };
        debug_assert_eq!(
            type_token_count,
            field_tok.component_token_count as usize - 2
        );
        debug_assert_eq!(current[type_token_count - 1].signal, Signal::EndField);

        let off = type_tok.offset as usize;
        let len = type_tok.encoded_length as usize;
        let segment = &msg_buf[off..off + len];

        match type_tok.signal {
            Signal::BeginComposite => {
                println!(
                    "->- Composite@{}[{type_token_count}] {off} : {type_tok:?}",
                    type_tok.i
                );
                debug_assert!(type_token_count >= 2);
                let Some((inner, _)) = current.split_at_checked(type_token_count - 2) else {
                    println!("no composite");
                    break;
                };
                decode_composite(
                    field_tok,
                    type_tok,
                    &inner,
                    segment,
                    acting_version,
                    listener,
                );
                debug_assert_eq!(current[type_token_count - 2].signal, Signal::EndComposite);
            }
            Signal::BeginEnum => {
                listener
                    .on_enum(
                        field_tok,
                        type_tok,
                        segment,
                        &current[..type_token_count - 2],
                        acting_version,
                    )
                    .unwrap();
            }
            Signal::BeginSet => {
                listener
                    .on_bit_set(
                        field_tok,
                        type_tok,
                        segment,
                        &current[..type_token_count - 2],
                        acting_version,
                    )
                    .unwrap();
            }
            Signal::Encoding => {
                let _count = len / type_tok.encoding.primitive_type.size();
                let end = off + type_tok.encoding.primitive_type.size(); //TODO: add count?
                listener
                    .on_encoding(field_tok, segment, type_tok, acting_version)
                    .unwrap();
            }
            _ => {
                println!("unknown type");
            }
        }
        tokens = next;
    }
    tokens
}

fn decode_composite<'b, L>(
    field_token: &Token,
    composite_token: &Token,
    tokens: &[Token],
    msg_buf: &'b [u8],
    acting_version: i32,
    listener: &mut L,
) -> &'b [u8]
where
    L: TokenListener,
{
    listener
        .on_begin_composite(field_token, composite_token, &tokens)
        .unwrap();
    println!(
        "--> Composite {:?} : {msg_buf:?}",
        tokens
            .iter()
            .map(|x| (&x.signal, &x.name))
            .collect::<Vec<_>>()
    );

    let mut xtokens = tokens;
    loop {
        let Some((type_tok, rest)) = xtokens.split_first() else {
            break;
        };
        let type_token_count = type_tok.component_token_count as usize;
        match type_tok.signal {
            Signal::BeginComposite => {
                println!("Compositeception! {type_tok:?}");
                let off = type_tok.offset as usize;
                let len = type_tok.encoded_length as usize;
                decode_composite(
                    field_token,
                    type_tok,
                    &rest[..type_token_count - 2],
                    &msg_buf[off..off + len],
                    acting_version,
                    listener,
                );
                xtokens = &rest[type_token_count - 1..];
            }
            Signal::BeginEnum => {
                let off = type_tok.offset as usize;
                let len = type_tok.encoded_length as usize;
                listener
                    .on_enum(
                        field_token,
                        type_tok,
                        &msg_buf[off..off + len],
                        &rest[..type_token_count - 2],
                        acting_version,
                    )
                    .unwrap();
                xtokens = &rest[type_token_count - 1..];
            }
            Signal::BeginSet => {
                let off = type_tok.offset as usize;
                let len = type_tok.encoded_length as usize;
                listener
                    .on_bit_set(
                        field_token,
                        type_tok,
                        &msg_buf[off..off + len],
                        &rest[..type_token_count - 2],
                        acting_version,
                    )
                    .unwrap();
                xtokens = &rest[type_token_count - 1..];
            }
            Signal::Encoding => {
                // println!("encoding {type_tok:?}");
                let name = &type_tok.name;
                let s = type_tok.offset as usize;
                let e = s + type_tok.encoded_length as usize;
                let seg = &msg_buf[s..e];
                let p = PrimitiveValue::new(type_tok.encoding.primitive_type, seg);
                // println!("    {name}: {{{}}} {p:?} = {seg:02X?}", p.to_string());
                listener
                    .on_encoding(field_token, seg, type_tok, acting_version)
                    .unwrap();
                xtokens = &rest[type_token_count - 1..];
            }
            _ => {
                panic!(
                    "unknown type in composite {:?}@{}",
                    type_tok.signal, type_tok.i
                );
            }
        }
    }

    listener.on_end_composite(field_token, &tokens).unwrap();
    &[]
}