Struct FinalClassification 

pub struct FinalClassification {
    pub header: Header,
    pub number_of_cars: u8,
    pub final_classification_data: Vec<FinalClassificationData>,
}

Fields

header: Header

number_of_cars: u8

final_classification_data: Vec<FinalClassificationData>

Implementations

impl FinalClassification

pub fn player_data(&self) -> &FinalClassificationData

Examples found in repository

examples/f1_2020.rs (line 54)

fn main() {
    let server =
        TelemetryServer::<F1_2020>::new("127.0.0.1:20777").expect("failed to bind to address");
    println!("listening on 127.0.0.1:20777...");

    loop {
        let event = server.next();

        if let Err(e) = event {
            println!("error: {:?}", e);
            continue;
        }

        match event.unwrap() {
            F1_2020::Motion(data) => println!(
                "Motion packet received: {:?}",
                data.player_data().world_position
            ),
            F1_2020::Session(data) => println!(
                "Session packet received: {:?}, {:?}, {:?}, {:?}",
                data.formula, data.session_type, data.track, data.weather
            ),
            F1_2020::LapData(data) => println!(
                "LapData packet received: {:?}, {:?}, {:?}",
                data.player_data().current_lap_time,
                data.player_data().pit_status,
                data.player_data().driver_status,
            ),
            F1_2020::Event(data) => {
                println!("Event packet received: {:?}", data.event_data_details)
            }
            F1_2020::Participants(data) => println!(
                "Participants packet received: {:?}",
                data.player_data().name
            ),
            F1_2020::CarSetup(data) => println!(
                "CarSetups packet received: {:?}",
                data.player_data().fuel_load
            ),
            F1_2020::CarTelemetry(data) => println!(
                "CarTelemtry packet received: {:?}, {:?}",
                data.mfd_panel,
                data.player_data()
            ),
            F1_2020::CarStatus(data) => println!(
                "CarStatus packet received: {:?}",
                data.player_data().drs_activation_distance
            ),
            F1_2020::FinalClassification(data) => println!(
                "FinalClassification packet received: {:?}",
                data.player_data()
            ),
            F1_2020::LobbyInfo(data) => {
                println!("LobbyInfo packet received: {:?}", data.players(),)
            }
        }
    }
}

Trait Implementations

impl BinRead for FinalClassification

type Args = ()

The type of arguments needed to be supplied in order to read this type, usually a tuple.

fn read_options<R: Read + Seek>( __binread_generated_var_reader: &mut R, __binread_generated_var_options: &ReadOptions, __binread_generated_var_arguments: Self::Args, ) -> BinResult<Self>

Read the type from the reader

fn read<R>(reader: &mut R) -> Result<Self, Error>

where R: Read + Seek,

Read the type from the reader while assuming no arguments have been passed

fn read_args<R>(reader: &mut R, args: Self::Args) -> Result<Self, Error>

where R: Read + Seek,

Read the type from the reader using the specified arguments

fn after_parse<R>( &mut self, _: &mut R, _: &ReadOptions, _: Self::Args, ) -> Result<(), Error>

where R: Read + Seek,

fn args_default() -> Option<Self::Args>

The default arguments to be used when using the read shortcut method. Override this for any type that optionally requries arguments

impl Debug for FinalClassification

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

Formats the value using the given formatter.