Struct lolrofl::Rofl

pub struct Rofl<'a> { /* private fields */ }

Base ROFL file parser

Usage

// Parse a file's content
// let content = std::fs::read("game.rofl").unwrap();
let game = lolrofl::Rofl::from_slice(&content[..]).unwrap();

let header = game.head(); // File header
let data = game.metadata(); // Game metadata JSON string
let payload = game.payload(); // Game payload

Implementations

impl Rofl<'_>

pub const MAGIC: [u8; 4] = _

Starting bytes of a ROFL file

This is public for ease of file recognition but should generally NOT be relied upon

pub fn head(&self) -> &BinHeader

Get the ROFL header

Examples

// let content = std::fs::read("game.rofl").unwrap();
let game = lolrofl::Rofl::from_slice(&content[..]).unwrap();
println!("Expected file length: {} bytes", game.head().file_len());

pub fn metadata(&self) -> Result<&str, Errors>

Get the loaded JSON Metadata string

Warning

The returned string is not guaranteed to be valid if the file is malformed

Examples

// let content = std::fs::read("game.rofl").unwrap();
let game = lolrofl::Rofl::from_slice(&content[..]).unwrap();
let meta = json::parse(game.metadata().unwrap()).unwrap();
println!("Duration: {} ms", meta["gameLength"]);
println!("Patch: {}", meta["gameVersion"]);

pub fn payload(&self) -> Result<PayloadHeader, Errors>

Get the loaded payload header

Examples

// let content = std::fs::read("game.rofl").unwrap();
let game = lolrofl::Rofl::from_slice(&content[..]).unwrap();

let payload = game.payload().unwrap();
println!("Game ID: {}", payload.id());
println!("Duration: {} ms", payload.duration());

pub fn segment_iter<'a>(
    &'a self,
    with_data: bool
) -> Result<PayloadIterator<'a>, Errors>

Get an iterator over the payload’s segments

with_data is implicitly false if the lib was compiled without the payload feature

Examples

// let content = std::fs::read("game.rofl").unwrap();
let game = lolrofl::Rofl::from_slice(&content[..]).unwrap();

for segment in game.segment_iter(false).unwrap() {
    println("{} {}", if segment.is_chunk() { "Chunk" } else { "Keyframe" }, segment.id())
}

// Truncated file
// let content = std::fs::read("game.rofl").unwrap();
let game = lolrofl::Rofl::from_slice(&content[..]).unwrap();

let mut data = game.segment_iter(false);
assert_eq!(data.is_err(), true)

pub fn from_slice<'a>(slice: &'a [u8]) -> Result<Rofl<'a>, Errors>

Create a new Rofl instance from a ROFL file’s slice

Panics

If the buffer contains less than 288 bytes - in the future, this will be an error

Errors

If the slice does not start with MAGIC

Examples

// let content = std::fs::read("game.rofl").unwrap();
let game = lolrofl::Rofl::from_slice(&content[..]).unwrap();