Struct brawl_api::model::players::battlelog::BattlePlayer

pub struct BattlePlayer {
    pub tag: String,
    pub name: String,
    pub brawler: BattleBrawler,
}

Represents a player in a BattleResultInfo object, with only partial data about it (note that the brawler field is exclusive to this struct, representing the brawler the player was using during the battle). One can use Player::fetch_from to obtain a full Player instance from an existing BattlePlayer instance.

Fields

tag: String

The player's tag.

name: String

The player's name.

brawler: BattleBrawler

The brawler the player was using during the battle.

Trait Implementations

impl Clone for BattlePlayer

fn clone(&self) -> BattlePlayer

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BattlePlayer

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

Formats the value using the given formatter.

impl Default for BattlePlayer

fn default() -> BattlePlayer

Returns an instance of BattlePlayer with initial values.

Examples

use brawl_api::{BattlePlayer, BattleBrawler};

assert_eq!(
    BattlePlayer::default(),
    BattlePlayer {
        tag: String::from(""),
        name: String::from(""),
        brawler: BattleBrawler::default(),
    }
);

impl<'de> Deserialize<'de> for BattlePlayer

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

Deserialize this value from the given Serde deserializer.

impl Eq for BattlePlayer

impl FetchFrom<BattlePlayer> for Player

fn fetch_from(client: &Client, b_player: &BattlePlayer) -> Result<Player>

(Async) Fetches a Player instance, given a preexisting BattlePlayer instance.

Errors

See Player::fetch.

Examples

use brawl_api::{
    Client, Player, BattleLog, Battle, BattleResultInfo, BattlePlayer,
    traits::*
};

let my_client = Client::new("my auth token");
let battlelog = BattleLog::fetch(&my_client, "#PLAYER_TAG_HERE")?;
let most_recent_battle: Option<&Battle> = battlelog.get(0);

if let Some(battle) = most_recent_battle {
    if let Some(ref teams) = &battle.result.teams {
        let some_b_player: &BattlePlayer = &teams[0][0];
        let some_player = Player::fetch_from(&my_client, some_b_player)?;
        // now `some_b_player`'s full data, as a Player, is available for use.
    }
}

fn a_fetch_from<'life0, 'life1, 'async_trait>(
    client: &'life0 Client,
    b_player: &'life1 BattlePlayer
) -> Pin<Box<dyn Future<Output = Result<Player>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait, 

(Async) Fetches a Player instance, given a preexisting BattlePlayer instance.

Errors

See Player::fetch.

Examples

use brawl_api::{
    Client, Player, BattleLog, Battle, BattleResultInfo, BattlePlayer,
    traits::*
};

let my_client = Client::new("my auth token");
let battlelog = BattleLog::a_fetch(&my_client, "#PLAYER_TAG_HERE").await?;
let most_recent_battle: Option<&Battle> = battlelog.get(0);

if let Some(battle) = most_recent_battle {
    if let Some(ref teams) = &battle.result.teams {
        let some_b_player: &BattlePlayer = &teams[0][0];
        let some_player = Player::a_fetch_from(&my_client, some_b_player).await?;
        // now `some_b_player`'s full data, as a Player, is available for use.
    }
}

impl Hash for BattlePlayer

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl PartialEq<BattlePlayer> for BattlePlayer

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

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

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

This method tests for !=.

impl Serialize for BattlePlayer

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

Serialize this value into the given Serde serializer.

impl StructuralEq for BattlePlayer

impl StructuralPartialEq for BattlePlayer