Enum boxcars::HeaderProp

pub enum HeaderProp {
    Array(Vec<Vec<(String, HeaderProp)>>),
    Bool(bool),
    Byte {
        kind: String,
        value: Option<String>,
    },
    Float(f32),
    Int(i32),
    Name(String),
    QWord(u64),
    Str(String),
}

All the interesting data are stored as properties in the header, properties such as:

• When and who scored a goal
• Player stats (goals, assists, score, etc).
• Date and level played on

A property can be a number, string, or a more complex object such as an array containing additional properties.

Variants

Array(Vec<Vec<(String, HeaderProp)>>)

Bool(bool)

Byte

Fields

kind: String

value: Option<String>

Float(f32)

Int(i32)

Name(String)

QWord(u64)

Str(String)

Implementations

impl HeaderProp

pub fn as_array(&self) -> Option<&Vec<Vec<(String, HeaderProp)>>>

If the HeaderProp is an array of properties, returns the array

let v = HeaderProp::Array(vec![
    vec![("abc".to_string(), HeaderProp::QWord(10))]
]);

assert_eq!(v.as_array().unwrap().len(), 1);
assert_eq!(v.as_array().unwrap()[0][0].1.as_array(), None);

pub fn as_bool(&self) -> Option<bool>

If the HeaderProp is a boolean, returns the value

let v = HeaderProp::Bool(true);
let b = HeaderProp::QWord(10);

assert_eq!(v.as_bool(), Some(true));
assert_eq!(b.as_bool(), None);

pub fn as_float(&self) -> Option<f32>

If the HeaderProp is a float, returns the value

let v = HeaderProp::Float(2.50);
let b = HeaderProp::QWord(10);

assert_eq!(v.as_float(), Some(2.50));
assert_eq!(b.as_float(), None);

pub fn as_u64(&self) -> Option<u64>

If the HeaderProp is a QWord, returns the value

let v = HeaderProp::QWord(250);
let b = HeaderProp::Bool(true);

assert_eq!(v.as_u64(), Some(250));
assert_eq!(b.as_u64(), None);

pub fn as_i32(&self) -> Option<i32>

If the HeaderProp is an int, returns the value

let v = HeaderProp::Int(-250);
let b = HeaderProp::Bool(true);

assert_eq!(v.as_i32(), Some(-250));
assert_eq!(b.as_i32(), None);

pub fn as_string(&self) -> Option<&str>

If the HeaderProp is an string, returns the value

let v = HeaderProp::Name("abc".to_string());
let x = HeaderProp::Str("def".to_string());
let b = HeaderProp::QWord(10);

assert_eq!(v.as_string(), Some("abc"));
assert_eq!(x.as_string(), Some("def"));
assert_eq!(b.as_i32(), None);

pub fn is_byte(&self) -> bool

Returns if the HeaderProp is a byte

let v = HeaderProp::Name("abc".to_string());
let b = HeaderProp::Byte {
    kind: String::from("OnlinePlatform"),
    value: None,   
};

assert_eq!(v.is_byte(), false);
assert_eq!(b.is_byte(), true);

Trait Implementations

impl Clone for HeaderProp

fn clone(&self) -> HeaderProp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for HeaderProp

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

Formats the value using the given formatter.

impl PartialEq<HeaderProp> for HeaderProp

fn eq(&self, other: &HeaderProp) -> bool

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

const fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for HeaderProp

By default serde will generate a serialization method that writes out the enum as well as the enum value. Since header values are self describing in JSON, we do not need to serialize the enum type. This is slightly lossy as in the serialized format it will be ambiguous if a value is a Name or Str, as well as Byte, Float, Int, or QWord.

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

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for HeaderProp