Struct TeamRecord 

pub struct TeamRecord<H: StandingsHydrations> {

    pub team: H::Team,
    pub season: SeasonId,
    pub games_played: usize,
    pub runs_allowed: usize,
    pub runs_scored: usize,
    pub is_divisional_champion: bool,
    pub is_divisional_leader: bool,
    pub has_wildcard: bool,
    pub last_updated: NaiveDateTime,
    pub streak: Streak,
    pub splits: RecordSplits,
    pub clinch_kind: ClinchKind,
    pub games_back: GamesBack,
    pub wild_card_games_back: GamesBack,
    pub league_games_back: GamesBack,
    pub spring_training_games_back: GamesBack,
    pub sport_games_back: GamesBack,
    pub division_games_back: GamesBack,
    pub conference_games_back: GamesBack,
    pub record: Record,
    pub divisional_rank: Option<usize>,
    pub league_rank: Option<usize>,
    pub sport_rank: Option<usize>,
}

Main bulk of the response; the team’s record and standings information. Lots of stuff here.

Fields

team: H::Team

season: SeasonId

games_played: usize

runs_allowed: usize

runs_scored: usize

is_divisional_champion: bool

is_divisional_leader: bool

has_wildcard: bool

last_updated: NaiveDateTime

streak: Streak

splits: RecordSplits

clinch_kind: ClinchKind

games_back: GamesBack

wild_card_games_back: GamesBack

league_games_back: GamesBack

spring_training_games_back: GamesBack

sport_games_back: GamesBack

division_games_back: GamesBack

conference_games_back: GamesBack

record: Record

divisional_rank: Option<usize>

league_rank: Option<usize>

sport_rank: Option<usize>

Implementations

impl<H: StandingsHydrations> TeamRecord<H>

pub fn expected_win_loss_pct(&self) -> ThreeDecimalPlaceRateStat

Uses the pythagorean expected win loss pct formula

pub fn expected_end_of_season_record(&self) -> Record

Assumes 162 total games. Recommended to use the other function if available

See Self::expected_end_of_season_record_with_total_games

pub fn expected_end_of_season_record_with_total_games( &self, total_games: usize, ) -> Record

Expected record at the end of the season considering the games already played and the expected win loss pct.

pub fn run_differential(&self) -> isize

Net runs scored for the team

Trait Implementations

impl<H: Clone + StandingsHydrations> Clone for TeamRecord<H>

where H::Team: Clone,

fn clone(&self) -> TeamRecord<H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: Debug + StandingsHydrations> Debug for TeamRecord<H>

where H::Team: Debug,

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

Formats the value using the given formatter.

impl<H: StandingsHydrations> Deref for TeamRecord<H>

type Target = Record

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<H: StandingsHydrations> DerefMut for TeamRecord<H>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'de, H> Deserialize<'de> for TeamRecord<H>

where H: StandingsHydrations,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<H: PartialEq + StandingsHydrations> PartialEq for TeamRecord<H>

where H::Team: PartialEq,

fn eq(&self, other: &TeamRecord<H>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<H: StandingsHydrations> StructuralPartialEq for TeamRecord<H>