Struct boxcars::Replay

pub struct Replay<'a> {
    pub header_size: i32,
    pub header_crc: i32,
    pub major_version: i32,
    pub minor_version: i32,
    pub net_version: Option<i32>,
    pub game_type: Cow<'a, str>,
    pub properties: Vec<(&'a str, HeaderProp<'a>)>,
    pub content_size: i32,
    pub content_crc: i32,
    pub network_frames: Option<NetworkFrames>,
    pub levels: Vec<Cow<'a, str>>,
    pub keyframes: Vec<KeyFrame>,
    pub debug_info: Vec<DebugInfo<'a>>,
    pub tick_marks: Vec<TickMark<'a>>,
    pub packages: Vec<Cow<'a, str>>,
    pub objects: Vec<Cow<'a, str>>,
    pub names: Vec<Cow<'a, str>>,
    pub class_indices: Vec<ClassIndex<'a>>,
    pub net_cache: Vec<ClassNetCache>,
}

The structure that a rocket league replay is parsed into.

Fields

header_size: i32

header_crc: i32

major_version: i32

minor_version: i32

net_version: Option<i32>

game_type: Cow<'a, str>

properties: Vec<(&'a str, HeaderProp<'a>)>

Could use a map to represent properties but I don't want to assume that duplicate keys can't exist, so to be safe, use a traditional vector.

content_size: i32

content_crc: i32

network_frames: Option<NetworkFrames>

levels: Vec<Cow<'a, str>>

keyframes: Vec<KeyFrame>

debug_info: Vec<DebugInfo<'a>>

tick_marks: Vec<TickMark<'a>>

packages: Vec<Cow<'a, str>>

objects: Vec<Cow<'a, str>>

names: Vec<Cow<'a, str>>

class_indices: Vec<ClassIndex<'a>>

net_cache: Vec<ClassNetCache>

Trait Implementations

impl<'a> PartialEq<Replay<'a>> for Replay<'a>

fn eq(&self, other: &Replay<'a>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Replay<'a>) -> bool

This method tests for !=.

impl<'a> Clone for Replay<'a>

fn clone(&self) -> Replay<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for Replay<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'a> Serialize for Replay<'a>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.