Struct HistoricalComparisons 

pub struct HistoricalComparisons {
    pub comparisons: Vec<HistoricalComparison>,
    pub metadata: WeatherMetadata,
}

Fields

comparisons: Vec<HistoricalComparison>

metadata: WeatherMetadata

Implementations

impl HistoricalComparisons

pub fn len(&self) -> usize

Examples found in repository

examples/13_weather_changes_snapshot.rs (line 26)

fn main() -> Result<(), Box<dyn Error>> {
    let service = WeatherService::shared();
    let location = support::sample_location();

    if let Some(changes) = support::handle_result("weather changes", service.weather_changes(&location))? {
        match changes {
            Some(changes) => println!("changes={} metadata_date={}", changes.len(), changes.metadata.date),
            None => println!("changes=none"),
        }
    }

    if let Some(comparisons) = support::handle_result(
        "historical comparisons",
        service.historical_comparisons(&location),
    )? {
        match comparisons {
            Some(comparisons) => println!(
                "historical_comparisons={} metadata_date={}",
                comparisons.len(), comparisons.metadata.date
            ),
            None => println!("historical_comparisons=none"),
        }
    }

    support::finish("weather changes");
    Ok(())
}

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> Iter<'_, HistoricalComparison>

Trait Implementations

impl Clone for HistoricalComparisons

fn clone(&self) -> HistoricalComparisons

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HistoricalComparisons

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HistoricalComparisons

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'a> IntoIterator for &'a HistoricalComparisons

type Item = &'a HistoricalComparison

The type of the elements being iterated over.

type IntoIter = Iter<'a, HistoricalComparison>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq for HistoricalComparisons

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