Struct WeatherService 

pub struct WeatherService { /* private fields */ }

Implementations

impl WeatherService

pub const fn shared() -> Self

Examples found in repository

examples/09_sun_events_snapshot.rs (line 9)

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

    if let Some(sun) = support::handle_result("sun events", service.sun_events(&location))? {
        println!("sunrise={:?} sunset={:?}", sun.sunrise, sun.sunset);
    }

    support::finish("sun events");
    Ok(())
}

examples/08_weather_attribution_snapshot.rs (line 9)

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

    if let Some(attribution) = support::handle_result("weather attribution", service.attribution())?
    {
        println!(
            "service={} legal_page={}",
            attribution.service_name, attribution.legal_page_url
        );
    }

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

examples/10_moon_events_snapshot.rs (line 9)

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

    if let Some(moon) = support::handle_result("moon events", service.moon_events(&location))? {
        println!(
            "phase={:?} moonrise={:?} moonset={:?}",
            moon.phase, moon.moonrise, moon.moonset
        );
    }

    support::finish("moon events");
    Ok(())
}

examples/05_weather_alerts_snapshot.rs (line 9)

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

    if let Some(alerts) =
        support::handle_result("weather alerts", service.weather_alerts(&location))?
    {
        let first_severity = alerts.first().map(WeatherAlert::severity_kind);
        println!("alerts={} first_severity={first_severity:?}", alerts.len());
    }

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

examples/01_weather_service_smoke.rs (line 9)

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

    if let Some(weather) = support::handle_result("weather service", service.weather(&location))? {
        println!(
            "current={:.1}°C hourly={} daily={} alerts={}",
            weather.current_weather.temperature,
            weather.hourly_forecast.len(),
            weather.daily_forecast.len(),
            weather.weather_alerts.len()
        );
    }

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

examples/02_current_weather_snapshot.rs (line 9)

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

    if let Some(current) =
        support::handle_result("current weather", service.current_weather(&location))?
    {
        println!(
            "temp={:.1}°C feels_like={:.1}°C pressure={:.1}hPa daylight={}",
            current.temperature,
            current.feels_like,
            current.pressure_reading().value,
            current.is_daylight
        );
    }

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

Additional examples can be found in:

• examples/06_minute_forecast_snapshot.rs
• examples/12_pressure_catalog.rs
• examples/03_daily_forecast_snapshot.rs
• examples/04_hourly_forecast_snapshot.rs
• examples/01_weather_smoke.rs
• examples/13_weather_changes_snapshot.rs
• examples/15_weather_multi_query_snapshot.rs
• examples/14_weather_statistics_snapshot.rs

pub const fn new() -> Self

pub fn attribution(&self) -> Result<WeatherAttribution, WeatherKitError>

Examples found in repository

examples/08_weather_attribution_snapshot.rs (line 11)

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

    if let Some(attribution) = support::handle_result("weather attribution", service.attribution())?
    {
        println!(
            "service={} legal_page={}",
            attribution.service_name, attribution.legal_page_url
        );
    }

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

pub fn weather(&self, location: &CLLocation) -> Result<Weather, WeatherKitError>

Examples found in repository

examples/01_weather_service_smoke.rs (line 12)

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

    if let Some(weather) = support::handle_result("weather service", service.weather(&location))? {
        println!(
            "current={:.1}°C hourly={} daily={} alerts={}",
            weather.current_weather.temperature,
            weather.hourly_forecast.len(),
            weather.daily_forecast.len(),
            weather.weather_alerts.len()
        );
    }

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

examples/01_weather_smoke.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let service = WeatherService::shared();
    let location = CLLocation::new(37.3349, -122.0090);

    match service.weather(&location) {
        Ok(weather) => {
            println!(
                "current temperature: {:.1}°C",
                weather.current_weather.temperature
            );
        }
        Err(error) if error.is_entitlement_issue() => {
            eprintln!("weatherkit requires entitled bundle ID; check developer.apple.com/account");
        }
        Err(error) => return Err(error.into()),
    }

    println!("✅ weatherkit smoke (with caveats)");
    Ok(())
}

pub fn current_weather( &self, location: &CLLocation, ) -> Result<CurrentWeather, WeatherKitError>

Examples found in repository

examples/02_current_weather_snapshot.rs (line 13)

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

    if let Some(current) =
        support::handle_result("current weather", service.current_weather(&location))?
    {
        println!(
            "temp={:.1}°C feels_like={:.1}°C pressure={:.1}hPa daylight={}",
            current.temperature,
            current.feels_like,
            current.pressure_reading().value,
            current.is_daylight
        );
    }

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

pub fn hourly_forecast( &self, location: &CLLocation, ) -> Result<HourlyForecast, WeatherKitError>

Examples found in repository

examples/04_hourly_forecast_snapshot.rs (line 13)

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

    if let Some(hourly) =
        support::handle_result("hourly forecast", service.hourly_forecast(&location))?
    {
        if let Some(first) = hourly.forecast.first() {
            println!(
                "first_hour={} temp={:.1}°C precip={:?} wind={:.1}m/s",
                first.date, first.temperature, first.precipitation, first.wind.speed
            );
        } else {
            println!("hourly forecast returned no hours");
        }
    }

    support::finish("hourly forecast");
    Ok(())
}

pub fn hourly_forecast_in( &self, location: &CLLocation, interval: DateInterval, ) -> Result<HourlyForecast, WeatherKitError>

pub fn daily_forecast( &self, location: &CLLocation, ) -> Result<DailyForecast, WeatherKitError>

Examples found in repository

examples/03_daily_forecast_snapshot.rs (line 13)

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

    if let Some(daily) =
        support::handle_result("daily forecast", service.daily_forecast(&location))?
    {
        if let Some(first) = daily.forecast.first() {
            println!(
                "first_day={} high={:.1}°C low={:.1}°C sunrise={:?}",
                first.date, first.high_temperature, first.low_temperature, first.sun.sunrise
            );
        } else {
            println!("daily forecast returned no days");
        }
    }

    support::finish("daily forecast");
    Ok(())
}

pub fn daily_forecast_in( &self, location: &CLLocation, interval: DateInterval, ) -> Result<DailyForecast, WeatherKitError>

pub fn minute_forecast( &self, location: &CLLocation, ) -> Result<Option<MinuteForecastCollection>, WeatherKitError>

Examples found in repository

examples/06_minute_forecast_snapshot.rs (line 13)

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

    if let Some(minute) =
        support::handle_result("minute forecast", service.minute_forecast(&location))?
    {
        if let Some(minute) = minute {
            println!(
                "summary={} entries={}",
                minute.summary,
                minute.forecast.len()
            );
        } else {
            println!("minute forecast unavailable for this location");
        }
    }

    support::finish("minute forecast");
    Ok(())
}

pub fn weather_alerts( &self, location: &CLLocation, ) -> Result<Vec<WeatherAlert>, WeatherKitError>

Examples found in repository

examples/05_weather_alerts_snapshot.rs (line 13)

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

    if let Some(alerts) =
        support::handle_result("weather alerts", service.weather_alerts(&location))?
    {
        let first_severity = alerts.first().map(WeatherAlert::severity_kind);
        println!("alerts={} first_severity={first_severity:?}", alerts.len());
    }

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

pub fn availability( &self, location: &CLLocation, ) -> Result<WeatherAvailability, WeatherKitError>

pub fn weather_including( &self, location: &CLLocation, query: WeatherQuery, ) -> Result<WeatherQueryResult, WeatherKitError>

pub fn weather_including2( &self, location: &CLLocation, query1: WeatherQuery, query2: WeatherQuery, ) -> Result<(WeatherQueryResult, WeatherQueryResult), WeatherKitError>

pub fn weather_including3( &self, location: &CLLocation, query1: WeatherQuery, query2: WeatherQuery, query3: WeatherQuery, ) -> Result<(WeatherQueryResult, WeatherQueryResult, WeatherQueryResult), WeatherKitError>

Examples found in repository

examples/15_weather_multi_query_snapshot.rs (lines 14-19)

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

    if let Some((current, daily, changes)) = support::handle_result(
        "weather multi query",
        service.weather_including3(
            &location,
            WeatherQuery::Current,
            WeatherQuery::Daily,
            WeatherQuery::Changes,
        ),
    )? {
        if let WeatherQueryResult::CurrentWeather(current) = current {
            println!("multi_query_current_temperature={:.1}", current.temperature);
        }
        if let WeatherQueryResult::DailyForecast(daily) = daily {
            println!("multi_query_daily_days={}", daily.len());
        }
        if let WeatherQueryResult::WeatherChanges(changes) = changes {
            println!("multi_query_changes_present={}", changes.is_some());
        }
    }

    support::finish("weather multi query");
    Ok(())
}

pub fn weather_including4( &self, location: &CLLocation, query1: WeatherQuery, query2: WeatherQuery, query3: WeatherQuery, query4: WeatherQuery, ) -> Result<(WeatherQueryResult, WeatherQueryResult, WeatherQueryResult, WeatherQueryResult), WeatherKitError>

pub fn weather_including5( &self, location: &CLLocation, query1: WeatherQuery, query2: WeatherQuery, query3: WeatherQuery, query4: WeatherQuery, query5: WeatherQuery, ) -> Result<(WeatherQueryResult, WeatherQueryResult, WeatherQueryResult, WeatherQueryResult, WeatherQueryResult), WeatherKitError>

pub fn weather_including6( &self, location: &CLLocation, query1: WeatherQuery, query2: WeatherQuery, query3: WeatherQuery, query4: WeatherQuery, query5: WeatherQuery, query6: WeatherQuery, ) -> Result<(WeatherQueryResult, WeatherQueryResult, WeatherQueryResult, WeatherQueryResult, WeatherQueryResult, WeatherQueryResult), WeatherKitError>

pub fn weather_including_many<I>( &self, location: &CLLocation, queries: I, ) -> Result<Vec<WeatherQueryResult>, WeatherKitError>

where I: IntoIterator<Item = WeatherQuery>,

pub fn weather_changes( &self, location: &CLLocation, ) -> Result<Option<WeatherChanges>, WeatherKitError>

Examples found in repository

examples/13_weather_changes_snapshot.rs (line 12)

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 historical_comparisons( &self, location: &CLLocation, ) -> Result<Option<HistoricalComparisons>, WeatherKitError>

Examples found in repository

examples/13_weather_changes_snapshot.rs (line 21)

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 daily_statistics( &self, location: &CLLocation, query: DailyWeatherStatisticsQuery, ) -> Result<DailyWeatherStatisticsResult, WeatherKitError>

Examples found in repository

examples/14_weather_statistics_snapshot.rs (line 21)

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

    if let Some(result) = support::handle_result(
        "daily statistics",
        service.daily_statistics(&location, DailyWeatherStatisticsQuery::Temperature),
    )? {
        match result {
            DailyWeatherStatisticsResult::Temperature(stats) => {
                println!("daily_temperature_stats={}", stats.len());
            }
            DailyWeatherStatisticsResult::Precipitation(stats) => {
                println!("daily_precipitation_stats={}", stats.len());
            }
        }
    }

    if let Some(result) = support::handle_result(
        "daily summary",
        service.daily_summary_in(
            &location,
            sample_interval(7),
            DailyWeatherSummaryQuery::Precipitation,
        ),
    )? {
        match result {
            DailyWeatherSummaryResult::Temperature(days) => {
                println!("daily_temperature_summary={}", days.len());
            }
            DailyWeatherSummaryResult::Precipitation(days) => {
                println!("daily_precipitation_summary={}", days.len());
            }
        }
    }

    if let Some(hourly) = support::handle_result(
        "hourly statistics",
        service.hourly_statistics(&location, HourlyWeatherStatisticsQuery::Temperature),
    )? {
        println!("hourly_temperature_stats={}", hourly.len());
    }

    if let Some(result) = support::handle_result(
        "monthly statistics",
        service.monthly_statistics_in(
            &location,
            sample_interval(120),
            MonthlyWeatherStatisticsQuery::Precipitation,
        ),
    )? {
        match result {
            MonthlyWeatherStatisticsResult::Temperature(stats) => {
                println!("monthly_temperature_stats={}", stats.len());
            }
            MonthlyWeatherStatisticsResult::Precipitation(stats) => {
                println!("monthly_precipitation_stats={}", stats.len());
            }
        }
    }

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

pub fn daily_statistics_in( &self, location: &CLLocation, interval: DateInterval, query: DailyWeatherStatisticsQuery, ) -> Result<DailyWeatherStatisticsResult, WeatherKitError>

pub fn daily_statistics_between_days( &self, location: &CLLocation, start_day: i64, end_day: i64, query: DailyWeatherStatisticsQuery, ) -> Result<DailyWeatherStatisticsResult, WeatherKitError>

pub fn daily_summary( &self, location: &CLLocation, query: DailyWeatherSummaryQuery, ) -> Result<DailyWeatherSummaryResult, WeatherKitError>

pub fn daily_summary_in( &self, location: &CLLocation, interval: DateInterval, query: DailyWeatherSummaryQuery, ) -> Result<DailyWeatherSummaryResult, WeatherKitError>

Examples found in repository

examples/14_weather_statistics_snapshot.rs (lines 35-39)

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

    if let Some(result) = support::handle_result(
        "daily statistics",
        service.daily_statistics(&location, DailyWeatherStatisticsQuery::Temperature),
    )? {
        match result {
            DailyWeatherStatisticsResult::Temperature(stats) => {
                println!("daily_temperature_stats={}", stats.len());
            }
            DailyWeatherStatisticsResult::Precipitation(stats) => {
                println!("daily_precipitation_stats={}", stats.len());
            }
        }
    }

    if let Some(result) = support::handle_result(
        "daily summary",
        service.daily_summary_in(
            &location,
            sample_interval(7),
            DailyWeatherSummaryQuery::Precipitation,
        ),
    )? {
        match result {
            DailyWeatherSummaryResult::Temperature(days) => {
                println!("daily_temperature_summary={}", days.len());
            }
            DailyWeatherSummaryResult::Precipitation(days) => {
                println!("daily_precipitation_summary={}", days.len());
            }
        }
    }

    if let Some(hourly) = support::handle_result(
        "hourly statistics",
        service.hourly_statistics(&location, HourlyWeatherStatisticsQuery::Temperature),
    )? {
        println!("hourly_temperature_stats={}", hourly.len());
    }

    if let Some(result) = support::handle_result(
        "monthly statistics",
        service.monthly_statistics_in(
            &location,
            sample_interval(120),
            MonthlyWeatherStatisticsQuery::Precipitation,
        ),
    )? {
        match result {
            MonthlyWeatherStatisticsResult::Temperature(stats) => {
                println!("monthly_temperature_stats={}", stats.len());
            }
            MonthlyWeatherStatisticsResult::Precipitation(stats) => {
                println!("monthly_precipitation_stats={}", stats.len());
            }
        }
    }

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

pub fn hourly_statistics( &self, location: &CLLocation, query: HourlyWeatherStatisticsQuery, ) -> Result<HourlyWeatherStatistics<HourTemperatureStatistics>, WeatherKitError>

Examples found in repository

examples/14_weather_statistics_snapshot.rs (line 53)

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

    if let Some(result) = support::handle_result(
        "daily statistics",
        service.daily_statistics(&location, DailyWeatherStatisticsQuery::Temperature),
    )? {
        match result {
            DailyWeatherStatisticsResult::Temperature(stats) => {
                println!("daily_temperature_stats={}", stats.len());
            }
            DailyWeatherStatisticsResult::Precipitation(stats) => {
                println!("daily_precipitation_stats={}", stats.len());
            }
        }
    }

    if let Some(result) = support::handle_result(
        "daily summary",
        service.daily_summary_in(
            &location,
            sample_interval(7),
            DailyWeatherSummaryQuery::Precipitation,
        ),
    )? {
        match result {
            DailyWeatherSummaryResult::Temperature(days) => {
                println!("daily_temperature_summary={}", days.len());
            }
            DailyWeatherSummaryResult::Precipitation(days) => {
                println!("daily_precipitation_summary={}", days.len());
            }
        }
    }

    if let Some(hourly) = support::handle_result(
        "hourly statistics",
        service.hourly_statistics(&location, HourlyWeatherStatisticsQuery::Temperature),
    )? {
        println!("hourly_temperature_stats={}", hourly.len());
    }

    if let Some(result) = support::handle_result(
        "monthly statistics",
        service.monthly_statistics_in(
            &location,
            sample_interval(120),
            MonthlyWeatherStatisticsQuery::Precipitation,
        ),
    )? {
        match result {
            MonthlyWeatherStatisticsResult::Temperature(stats) => {
                println!("monthly_temperature_stats={}", stats.len());
            }
            MonthlyWeatherStatisticsResult::Precipitation(stats) => {
                println!("monthly_precipitation_stats={}", stats.len());
            }
        }
    }

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

pub fn hourly_statistics_in( &self, location: &CLLocation, interval: DateInterval, query: HourlyWeatherStatisticsQuery, ) -> Result<HourlyWeatherStatistics<HourTemperatureStatistics>, WeatherKitError>

pub fn hourly_statistics_between_hours( &self, location: &CLLocation, start_hour: i64, end_hour: i64, query: HourlyWeatherStatisticsQuery, ) -> Result<HourlyWeatherStatistics<HourTemperatureStatistics>, WeatherKitError>

pub fn monthly_statistics( &self, location: &CLLocation, query: MonthlyWeatherStatisticsQuery, ) -> Result<MonthlyWeatherStatisticsResult, WeatherKitError>

pub fn monthly_statistics_in( &self, location: &CLLocation, interval: DateInterval, query: MonthlyWeatherStatisticsQuery, ) -> Result<MonthlyWeatherStatisticsResult, WeatherKitError>

Examples found in repository

examples/14_weather_statistics_snapshot.rs (lines 60-64)

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

    if let Some(result) = support::handle_result(
        "daily statistics",
        service.daily_statistics(&location, DailyWeatherStatisticsQuery::Temperature),
    )? {
        match result {
            DailyWeatherStatisticsResult::Temperature(stats) => {
                println!("daily_temperature_stats={}", stats.len());
            }
            DailyWeatherStatisticsResult::Precipitation(stats) => {
                println!("daily_precipitation_stats={}", stats.len());
            }
        }
    }

    if let Some(result) = support::handle_result(
        "daily summary",
        service.daily_summary_in(
            &location,
            sample_interval(7),
            DailyWeatherSummaryQuery::Precipitation,
        ),
    )? {
        match result {
            DailyWeatherSummaryResult::Temperature(days) => {
                println!("daily_temperature_summary={}", days.len());
            }
            DailyWeatherSummaryResult::Precipitation(days) => {
                println!("daily_precipitation_summary={}", days.len());
            }
        }
    }

    if let Some(hourly) = support::handle_result(
        "hourly statistics",
        service.hourly_statistics(&location, HourlyWeatherStatisticsQuery::Temperature),
    )? {
        println!("hourly_temperature_stats={}", hourly.len());
    }

    if let Some(result) = support::handle_result(
        "monthly statistics",
        service.monthly_statistics_in(
            &location,
            sample_interval(120),
            MonthlyWeatherStatisticsQuery::Precipitation,
        ),
    )? {
        match result {
            MonthlyWeatherStatisticsResult::Temperature(stats) => {
                println!("monthly_temperature_stats={}", stats.len());
            }
            MonthlyWeatherStatisticsResult::Precipitation(stats) => {
                println!("monthly_precipitation_stats={}", stats.len());
            }
        }
    }

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

pub fn monthly_statistics_between_months( &self, location: &CLLocation, start_month: i64, end_month: i64, query: MonthlyWeatherStatisticsQuery, ) -> Result<MonthlyWeatherStatisticsResult, WeatherKitError>

pub fn sun_events( &self, location: &CLLocation, ) -> Result<SunEvents, WeatherKitError>

Examples found in repository

examples/09_sun_events_snapshot.rs (line 12)

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

    if let Some(sun) = support::handle_result("sun events", service.sun_events(&location))? {
        println!("sunrise={:?} sunset={:?}", sun.sunrise, sun.sunset);
    }

    support::finish("sun events");
    Ok(())
}

pub fn moon_events( &self, location: &CLLocation, ) -> Result<MoonEvents, WeatherKitError>

Examples found in repository

examples/10_moon_events_snapshot.rs (line 12)

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

    if let Some(moon) = support::handle_result("moon events", service.moon_events(&location))? {
        println!(
            "phase={:?} moonrise={:?} moonset={:?}",
            moon.phase, moon.moonrise, moon.moonset
        );
    }

    support::finish("moon events");
    Ok(())
}

pub fn pressure( &self, location: &CLLocation, ) -> Result<Pressure, WeatherKitError>

Examples found in repository

examples/12_pressure_catalog.rs (line 20)

fn main() -> Result<(), Box<dyn Error>> {
    let descriptors = PressureTrend::descriptors()?;
    println!(
        "pressure_trends={:?}",
        descriptors
            .iter()
            .map(|d| d.raw_value.as_str())
            .collect::<Vec<_>>()
    );

    let service = WeatherService::shared();
    let location = support::sample_location();
    if let Some(pressure) = support::handle_result("pressure", service.pressure(&location))? {
        println!(
            "current_pressure={:.1}hPa trend={:?}",
            pressure.value, pressure.trend
        );
    }

    support::finish("pressure");
    Ok(())
}

Trait Implementations

impl Clone for WeatherService

fn clone(&self) -> WeatherService

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WeatherService

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

Formats the value using the given formatter.

impl Default for WeatherService

fn default() -> WeatherService

Returns the “default value” for a type.

impl Copy for WeatherService