Struct Brawler

pub struct Brawler {
    pub name: String,
    pub id: usize,
    pub star_powers: Vec<StarPower>,
}

Contains information for a specific brawler, and allows for it to be fetched through Brawler::fetch.

Fields

name: String

The brawler’s name, in CAPS LOCK. E.g.: "SHELLY" for Shelly.

id: usize

The brawler’s ID (an arbitrary number representing it).

star_powers: Vec<StarPower>

The brawler’s star powers, as a vector (note that this does not have a fixed size: new brawlers start with 1 star power, while older ones have at least 2.)

Implementations

impl Brawler

pub fn get_fetch_prop(&self) -> usize

Returns this Brawler’s ID, which is used for fetching.

Examples

use brawl_api::{Brawler, traits::*};

// given an existing Brawler object
let brawler: Brawler;

assert_eq!(brawler.get_fetch_prop(), brawler.id);

pub fn get_route(id: usize) -> Route

Returns the Route object required for fetching a Brawler instance.

Examples

use brawl_api::{BrawlerList, http::Route};

assert_eq!(
    BrawlerList::get_route(),
    Route::Brawlers
);

pub fn fetch(client: &Client, id: usize) -> Result<Brawler>

(Sync) Fetches data for a brawler with a specific ID (see the Brawlers enum for a humanized list with IDs).

Errors

This function may error:

• While requesting (will return an Error::Request);
• After receiving a bad status code (API or other error - returns an Error::Status);
• After a ratelimit is indicated by the API, while also specifying when it is lifted (Error::Ratelimited);
• While parsing incoming JSON (will return an Error::Json).

(All of those, of course, wrapped inside an Err.)

Examples

use brawl_api::{Client, Brawler, Brawlers, traits::*};

let my_client = Client::new("my auth token");
let shelly = Brawler::fetch(&my_client, Brawlers::Shelly as usize)?;
// now the data for Shelly is available.

pub async fn a_fetch(client: &Client, id: usize) -> Result<Brawler>

(Async) Fetches data for a brawler with a specific ID (see the Brawlers enum for a humanized list with IDs).

Errors

This function may error:

• While requesting (will return an Error::Request);
• After receiving a bad status code (API or other error - returns an Error::Status);
• After a ratelimit is indicated by the API, while also specifying when it is lifted (Error::Ratelimited);
• While parsing incoming JSON (will return an Error::Json).

(All of those, of course, wrapped inside an Err.)

Examples

use brawl_api::{Client, Brawler, Brawlers, traits::*};

let my_client = Client::new("my auth token");
let shelly = Brawler::a_fetch(&my_client, Brawlers::Shelly as usize).await?;
// now the data for Shelly is available.

Trait Implementations

impl Clone for Brawler

fn clone(&self) -> Brawler

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Brawler

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

Formats the value using the given formatter.

impl Default for Brawler

fn default() -> Brawler

Returns an instance of Brawler with initial values.

Examples

use brawl_api::Brawler;

assert_eq!(
    Brawler::default(),
    Brawler {
        name: String::from(""),
        id: 0,
        star_powers: vec![]
    }
);

impl<'de> Deserialize<'de> for Brawler

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FetchFrom<BattleBrawler> for Brawler

fn fetch_from(client: &Client, b_brawler: &BattleBrawler) -> Result<Brawler>

(Sync) Attempts to fetch a Brawler from an existing BattleBrawler instance.

fn a_fetch_from<'life0, 'life1, 'async_trait>( client: &'life0 Client, b_brawler: &'life1 BattleBrawler, ) -> Pin<Box<dyn Future<Output = Result<Brawler>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait,

(Async) Attempts to fetch a Brawler from an existing BattleBrawler instance.

impl FetchFrom<Brawlers> for Brawler

fn fetch_from(client: &Client, b_brawler: &Brawlers) -> Result<Brawler>

(Sync) Attempts to fetch a Brawler from an existing Brawlers variant.

fn a_fetch_from<'life0, 'life1, 'async_trait>( client: &'life0 Client, b_brawler: &'life1 Brawlers, ) -> Pin<Box<dyn Future<Output = Result<Brawler>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait,

(Async) Attempts to fetch a Brawler from an existing Brawlers variant.

impl FetchFrom<PlayerBrawlerStat> for Brawler

fn fetch_from(client: &Client, p_brawler: &PlayerBrawlerStat) -> Result<Brawler>

(Sync) Attempts to fetch a Brawler from an existing PlayerBrawlerStat instance.

fn a_fetch_from<'life0, 'life1, 'async_trait>( client: &'life0 Client, p_brawler: &'life1 PlayerBrawlerStat, ) -> Pin<Box<dyn Future<Output = Result<Brawler>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait,

(Async) Attempts to fetch a Brawler from an existing PlayerBrawlerStat instance.

impl Hash for Brawler

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Brawler

fn eq(&self, other: &Brawler) -> 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 Refetchable for Brawler

fn refetch(&self, client: &Client) -> Result<Brawler>

(Sync) Fetches data for this brawler again.

fn a_refetch<'life0, 'life1, 'async_trait>( &'life0 self, client: &'life1 Client, ) -> Pin<Box<dyn Future<Output = Result<Brawler>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

(Async) Fetches data for this brawler again.

fn refetch_update(&mut self, client: &Client) -> Result<&Self>

(Sync) Like refetch, but mutates the instance, returning an immutable reference to it.

fn a_refetch_update<'life0, 'async_trait>( &'async_trait mut self, client: &'life0 Client, ) -> Pin<Box<dyn Future<Output = Result<&'async_trait Self>> + Send + 'async_trait>>

where Self: Send + Sync + Send + 'async_trait, 'life0: 'async_trait,

(Async) Like a_refetch, but mutates the instance, returning an immutable reference to it.

impl Serialize for Brawler

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Brawler

impl StructuralPartialEq for Brawler