Struct livesplit_core::RunMetadata

pub struct RunMetadata {
    pub run_id: String,
    pub platform_name: String,
    pub uses_emulator: bool,
    pub region_name: String,
    pub variables: IndexMap<String, String>,
}

The Run Metadata stores additional information about a run, like the platform and region of the game. All of this information is optional.

Fields

run_id: String

The speedrun.com Run ID of the run. You need to ensure that the record on speedrun.com matches up with the Personal Best of this run. This may be empty if there's no association.

platform_name: String

The name of the platform this game is run on. This may be empty if it's not specified.

uses_emulator: bool

Specifies whether this speedrun is done on an emulator. Keep in mind that false may also mean that this information is simply not known.

region_name: String

The name of the region this game is from. This may be empty if it's not specified.

variables: IndexMap<String, String>

Stores all the variables. A variable is an arbitrary key value pair storing additional information about the category. An example of this may be whether Amiibos are used in this category.

Methods

impl RunMetadata

pub fn new() -> Self

Creates a new empty Run Metadata.

pub fn run_id(&self) -> &str

Accesses the speedrun.com Run ID of the run. This Run ID specify which Record on speedrun.com this run is associated with. This should be changed once the Personal Best doesn't match up with that record anymore. This may be empty if there's no association.

pub fn set_run_id<S>(&mut self, id: S) where
    S: AsRef<str>, 

Sets the speedrun.com Run ID of the run. You need to ensure that the record on speedrun.com matches up with the Personal Best of this run. This may be empty if there's no association.

pub fn platform_name(&self) -> &str

Accesses the name of the platform this game is run on. This may be empty if it's not specified.

pub fn set_platform_name<S>(&mut self, name: S) where
    S: AsRef<str>, 

Sets the name of the platform this game is run on. This may be empty if it's not specified.

pub fn uses_emulator(&self) -> bool

Returns true if this speedrun is done on an emulator. However false may also indicate that this information is simply not known.

pub fn set_emulator_usage(&mut self, uses_emulator: bool)

Specifies whether this speedrun is done on an emulator. Keep in mind that false may also mean that this information is simply not known.

pub fn region_name(&self) -> &str

Accesses the name of the region this game is from. This may be empty if it's not specified.

pub fn set_region_name<S>(&mut self, region_name: S) where
    S: AsRef<str>, 

Sets the name of the region this game is from. This may be empty if it's not specified.

pub fn set_variable<N, V>(&mut self, name: N, value: V) where
    N: Into<String>,
    V: Into<String>, 

Sets the variable with the name specified to the value specified. A variable is an arbitrary key value pair storing additional information about the category. An example of this may be whether Amiibos are used in this category. If the variable doesn't exist yet, it is being inserted.

pub fn remove_variable<S>(&mut self, name: S) where
    S: AsRef<str>, 

Removes the variable with the name specified.

pub fn variables(&self) -> Iter<String, String>

Returns an iterator iterating over all the variables and their values that have been specified.

pub fn clear(&mut self)

Resets all the Metadata Information.

Trait Implementations

impl Default for RunMetadata

fn default() -> RunMetadata

Returns the "default value" for a type.

impl Clone for RunMetadata

fn clone(&self) -> RunMetadata

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq<RunMetadata> for RunMetadata

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

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

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

This method tests for !=.

impl Debug for RunMetadata

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

Formats the value using the given formatter.

impl Serialize for RunMetadata

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

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for RunMetadata

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.