simple_sbe/

lib.rs

use crate::codec::Decoder;
use crate::codec::byte_order_codec::ByteOrderCodec;
use crate::codec::frame_codec_codec::FrameCodecDecoder;
use crate::codec::presence_codec::PresenceCodec;
use crate::codec::token_codec_codec::TokenCodecDecoder;
use crate::codec::{ReadBuf, frame_codec_codec, token_codec_codec};
use crate::token::{ByteOrder, Encoding, Presence, PrimitiveValue, Token};

mod codec;

pub mod decode;
pub mod otf;
pub mod token;

pub fn tokenize(svbuf: &[u8]) -> Vec<Token> {
    let schema_buf = ReadBuf::new(svbuf);

    let d = FrameCodecDecoder::default();
    let mut d = d.wrap(
        schema_buf,
        0,
        frame_codec_codec::SBE_BLOCK_LENGTH,
        frame_codec_codec::SBE_SCHEMA_VERSION,
    );

    dbg!(d.ir_id());
    dbg!(d.ir_version());
    dbg!(d.schema_version());

    // dbg!(d);

    let c = d.package_name_decoder();
    dbg!(
        c,
        String::from_utf8_lossy(d.package_name_slice(c)),
        d.get_limit()
    );

    let c = d.namespace_name_decoder();
    dbg!(
        c,
        String::from_utf8_lossy(d.namespace_name_slice(c)),
        d.get_limit()
    );

    let c = d.semantic_version_decoder();
    dbg!(
        c,
        String::from_utf8_lossy(d.semantic_version_slice(c)),
        d.get_limit()
    );

    let mut offset = d.encoded_length();

    println!("=== message ===");
    let mut tokens = Vec::new();
    let mut i = 0;
    while offset < svbuf.len() {
        dbg!(offset, svbuf.len());

        let mut d = TokenCodecDecoder::default().wrap(
            schema_buf,
            offset,
            token_codec_codec::SBE_BLOCK_LENGTH,
            token_codec_codec::SBE_SCHEMA_VERSION,
        );

        println!(">>> {:?}", d.signal());
        dbg!(d.token_offset(), d.token_size());
        dbg!(d.field_id());
        // dbg!(d.token_version());
        // dbg!(d.component_token_count());
        let primitive_type = dbg!(d.primitive_type()).into();
        let byte_order = match dbg!(d.byte_order()) {
            ByteOrderCodec::SBE_LITTLE_ENDIAN | ByteOrderCodec::NullVal => ByteOrder::LittleEndian,
            ByteOrderCodec::SBE_BIG_ENDIAN => ByteOrder::BigEndian,
        };
        let presence = match dbg!(d.presence()) {
            PresenceCodec::SBE_REQUIRED | PresenceCodec::NullVal => Presence::Required,
            PresenceCodec::SBE_OPTIONAL => Presence::Optional,
            PresenceCodec::SBE_CONSTANT => Presence::Constant,
        };

        // Note: var data must be decoded in the correct order!
        let c = d.name_decoder();
        let name = String::from_utf8_lossy(d.name_slice(c)).to_string();
        dbg!(&name);

        let c = d.const_value_decoder();
        let const_value = dbg!(PrimitiveValue::new(primitive_type, d.const_value_slice(c)));

        let c = d.min_value_decoder();
        let min_value = dbg!(PrimitiveValue::new(primitive_type, d.min_value_slice(c)));

        let c = d.max_value_decoder();
        let max_value = dbg!(PrimitiveValue::new(primitive_type, d.max_value_slice(c)));

        let c = d.null_value_decoder();
        let null_value = dbg!(PrimitiveValue::new(primitive_type, d.null_value_slice(c)));

        let c = d.character_encoding_decoder();
        let character_encoding = String::from_utf8_lossy(d.character_encoding_slice(c)).to_string();

        let c = d.epoch_decoder();
        let epoch = String::from_utf8_lossy(d.epoch_slice(c)).to_string();

        let c = d.time_unit_decoder();
        let time_unit = String::from_utf8_lossy(d.time_unit_slice(c)).to_string();

        let c = d.semantic_type_decoder();
        let semantic_type = String::from_utf8_lossy(d.semantic_type_slice(c)).to_string();

        let c = d.description_decoder();
        let description = String::from_utf8_lossy(d.description_slice(c)).to_string();

        let c = d.referenced_name_decoder();
        let referenced_name = String::from_utf8_lossy(d.referenced_name_slice(c)).to_string();

        let tok = Token {
            i,
            signal: d.signal().into(),
            name,
            referenced_name,
            description,
            // package_name,
            id: d.field_id(),
            version: d.token_version(),
            deprecated: d.deprecated(),
            encoded_length: d.token_size(),
            offset: d.token_offset(),
            component_token_count: d.component_token_count(),
            encoding: Encoding {
                presence,
                primitive_type,
                byte_order,
                const_value,
                min_value,
                max_value,
                null_value,
                character_encoding,
                epoch,
                time_unit,
                semantic_type,
            },
        };

        tokens.push(tok);
        i += 1;

        offset += d.encoded_length();
    }

    tokens
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::codec::frame_codec_codec::FrameCodecDecoder;
    use crate::codec::token_codec_codec::TokenCodecDecoder;
    use crate::codec::{Decoder, ReadBuf, frame_codec_codec, token_codec_codec};
    use anyhow::Result;
    use std::fs::File;
    use std::io::Read;

    #[test]
    fn load() -> Result<()> {
        // let mut f = File::open("../simple.sbeir")?;
        // let mut f = File::open("../example-schema.sbeir")?;
        let mut f = File::open("data/sbe-ir.sbeir")?;
        let mut buffer = Vec::new();

        f.read_to_end(&mut buffer)?;

        let buf = ReadBuf::new(&buffer);

        println!("{buf:?}");
        for (i, &c) in buffer.iter().enumerate() {
            println!("{i:>3} | {c:>3} {:>7}", (c as char).escape_default())
        }
        println!("");
        let mut d = FrameCodecDecoder::default();
        let mut d = d.wrap(
            buf,
            0,
            frame_codec_codec::SBE_BLOCK_LENGTH,
            frame_codec_codec::SBE_SCHEMA_VERSION,
        );
        dbg!(d.ir_id());
        dbg!(d.ir_version());
        dbg!(d.schema_version());

        // dbg!(d);

        let c = d.package_name_decoder();
        dbg!(
            c,
            String::from_utf8_lossy(d.package_name_slice(c)),
            d.get_limit()
        );

        let c = d.namespace_name_decoder();
        dbg!(
            c,
            String::from_utf8_lossy(d.namespace_name_slice(c)),
            d.get_limit()
        );

        let c = d.semantic_version_decoder();
        dbg!(
            c,
            String::from_utf8_lossy(d.semantic_version_slice(c)),
            d.get_limit()
        );

        let mut offset = d.encoded_length();

        while offset < buffer.len() {
            dbg!(offset, buffer.len());

            let mut d = TokenCodecDecoder::default().wrap(
                buf,
                offset,
                token_codec_codec::SBE_BLOCK_LENGTH,
                token_codec_codec::SBE_SCHEMA_VERSION,
            );

            println!(">>> {:?}", d.signal());
            dbg!(d.token_offset(), d.token_size());
            dbg!(d.field_id());
            dbg!(d.token_version());
            dbg!(d.component_token_count());
            dbg!(d.primitive_type());
            dbg!(d.byte_order());
            dbg!(d.presence());
            dbg!(d.deprecated());

            let c = d.name_decoder();
            dbg!(String::from_utf8_lossy(d.name_slice(c)));

            let c = d.const_value_decoder();
            dbg!(String::from_utf8_lossy(d.const_value_slice(c)));

            let c = d.min_value_decoder();
            dbg!(String::from_utf8_lossy(d.min_value_slice(c)));

            let c = d.max_value_decoder();
            dbg!(String::from_utf8_lossy(d.max_value_slice(c)));

            let c = d.null_value_decoder();
            dbg!(String::from_utf8_lossy(d.null_value_slice(c)));

            let c = d.character_encoding_decoder();
            dbg!(String::from_utf8_lossy(d.character_encoding_slice(c)));

            let c = d.epoch_decoder();
            dbg!(String::from_utf8_lossy(d.epoch_slice(c)));

            let c = d.time_unit_decoder();
            dbg!(String::from_utf8_lossy(d.time_unit_slice(c)));

            let c = d.semantic_type_decoder();
            dbg!(String::from_utf8_lossy(d.semantic_type_slice(c)));

            let c = d.description_decoder();
            dbg!(String::from_utf8_lossy(d.description_slice(c)));

            let c = d.referenced_name_decoder();
            dbg!(String::from_utf8_lossy(d.referenced_name_slice(c)));

            offset += d.encoded_length();
        }

        Ok(())
    }
}