Struct Decoder 

pub struct Decoder<R: Read> {
    pub library_registry: HashMap<i32, String>,
    pub offset: usize,
    /* private fields */
}

A decoder for MS-NRBF binary streams.

Fields

library_registry: HashMap<i32, String>

Registry of libraries by ID.

offset: usize

Current offset in the stream.

Implementations

impl<R: Read> Decoder<R>

pub fn new(reader: R) -> Self

Creates a new decoder from a reader.

Examples found in repository

examples/parse_meta.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <nrbf_file> [output_json]", args[0]);
        std::process::exit(1);
    }

    let file = File::open(&args[1])?;
    let reader = BufReader::new(file);
    let mut decoder = Decoder::new(reader);

    let mut records = Vec::new();
    while let Some(record) = decoder.decode_next()? {
        records.push(record);
        if let Record::MessageEnd = records.last().unwrap() {
            break;
        }
    }

    let output_path = args.get(2).map(|s| s.as_str()).unwrap_or("output.json");
    let json = serde_json::to_string_pretty(&records)?;

    let mut out_file = File::create(output_path)?;
    out_file.write_all(json.as_bytes())?;

    println!(
        "Successfully parsed {} records and saved to {}",
        records.len(),
        output_path
    );

    Ok(())
}

examples/round_trip.rs (line 38)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <nrbf_file>", args[0]);
        std::process::exit(1);
    }

    let input_path = &args[1];
    println!("Reading original file: {}", input_path);
    let file = File::open(input_path)?;
    let mut original_data = Vec::new();
    File::open(input_path)?.read_to_end(&mut original_data)?;

    let reader = BufReader::new(file);
    let mut decoder = Decoder::new(reader);

    let mut records = Vec::new();
    while let Some(record) = decoder.decode_next()? {
        let is_end = matches!(record, Record::MessageEnd);
        records.push(record);
        if is_end {
            break;
        }
    }
    println!("Parsed {} records.", records.len());

    // Serialize to JSON
    let json = serde_json::to_string_pretty(&records)?;
    let json_path = "output.json";
    std::fs::write(json_path, &json)?;
    println!("Saved records to {}", json_path);

    // Deserialize from JSON
    let deserialized_records: Vec<Record> = serde_json::from_str(&json)?;
    println!(
        "Deserialized {} records from JSON.",
        deserialized_records.len()
    );

    // Encode back to binary
    let output_path = "reconstructed.meta";
    let out_file = File::create(output_path)?;
    let mut encoder = Encoder::new(BufWriter::new(out_file));

    for record in &deserialized_records {
        encoder.encode(record)?;
    }
    // Ensure everything is flushed
    drop(encoder);
    println!("Reconstructed binary saved to {}", output_path);

    // Compare
    let mut reconstructed_data = Vec::new();
    File::open(output_path)?.read_to_end(&mut reconstructed_data)?;

    if original_data == reconstructed_data {
        println!("SUCCESS: Reconstructed binary is identical to original!");
    } else {
        println!("FAILURE: Reconstructed binary differs from original.");
        println!(
            "Original size: {}, Reconstructed size: {}",
            original_data.len(),
            reconstructed_data.len()
        );

        // Find first difference
        let min_len = std::cmp::min(original_data.len(), reconstructed_data.len());
        for i in 0..min_len {
            if original_data[i] != reconstructed_data[i] {
                println!(
                    "First difference at offset 0x{:x}: original 0x{:02x}, reconstructed 0x{:02x}",
                    i, original_data[i], reconstructed_data[i]
                );
                break;
            }
        }
    }

    Ok(())
}

pub fn decode_next(&mut self) -> Result<Option<Record>>

Decodes the next record from the stream.

Returns Ok(Some(record)) if a record was successfully read, Ok(None) if the end of the stream was reached, or an Err if parsing failed.

Examples found in repository

examples/parse_meta.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <nrbf_file> [output_json]", args[0]);
        std::process::exit(1);
    }

    let file = File::open(&args[1])?;
    let reader = BufReader::new(file);
    let mut decoder = Decoder::new(reader);

    let mut records = Vec::new();
    while let Some(record) = decoder.decode_next()? {
        records.push(record);
        if let Record::MessageEnd = records.last().unwrap() {
            break;
        }
    }

    let output_path = args.get(2).map(|s| s.as_str()).unwrap_or("output.json");
    let json = serde_json::to_string_pretty(&records)?;

    let mut out_file = File::create(output_path)?;
    out_file.write_all(json.as_bytes())?;

    println!(
        "Successfully parsed {} records and saved to {}",
        records.len(),
        output_path
    );

    Ok(())
}

examples/round_trip.rs (line 41)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = env::args().collect();
    if args.len() < 2 {
        eprintln!("Usage: {} <nrbf_file>", args[0]);
        std::process::exit(1);
    }

    let input_path = &args[1];
    println!("Reading original file: {}", input_path);
    let file = File::open(input_path)?;
    let mut original_data = Vec::new();
    File::open(input_path)?.read_to_end(&mut original_data)?;

    let reader = BufReader::new(file);
    let mut decoder = Decoder::new(reader);

    let mut records = Vec::new();
    while let Some(record) = decoder.decode_next()? {
        let is_end = matches!(record, Record::MessageEnd);
        records.push(record);
        if is_end {
            break;
        }
    }
    println!("Parsed {} records.", records.len());

    // Serialize to JSON
    let json = serde_json::to_string_pretty(&records)?;
    let json_path = "output.json";
    std::fs::write(json_path, &json)?;
    println!("Saved records to {}", json_path);

    // Deserialize from JSON
    let deserialized_records: Vec<Record> = serde_json::from_str(&json)?;
    println!(
        "Deserialized {} records from JSON.",
        deserialized_records.len()
    );

    // Encode back to binary
    let output_path = "reconstructed.meta";
    let out_file = File::create(output_path)?;
    let mut encoder = Encoder::new(BufWriter::new(out_file));

    for record in &deserialized_records {
        encoder.encode(record)?;
    }
    // Ensure everything is flushed
    drop(encoder);
    println!("Reconstructed binary saved to {}", output_path);

    // Compare
    let mut reconstructed_data = Vec::new();
    File::open(output_path)?.read_to_end(&mut reconstructed_data)?;

    if original_data == reconstructed_data {
        println!("SUCCESS: Reconstructed binary is identical to original!");
    } else {
        println!("FAILURE: Reconstructed binary differs from original.");
        println!(
            "Original size: {}, Reconstructed size: {}",
            original_data.len(),
            reconstructed_data.len()
        );

        // Find first difference
        let min_len = std::cmp::min(original_data.len(), reconstructed_data.len());
        for i in 0..min_len {
            if original_data[i] != reconstructed_data[i] {
                println!(
                    "First difference at offset 0x{:x}: original 0x{:02x}, reconstructed 0x{:02x}",
                    i, original_data[i], reconstructed_data[i]
                );
                break;
            }
        }
    }

    Ok(())
}