Struct SntpDateTime

pub struct SntpDateTime { /* private fields */ }

Represents a date and time

It’s main purpose is to have a wrapper for different date and time representations, which is usable regadless of the enabled time crate support.

It can be inspected directly, but there is no built-in timezone conversion, it will always return with UTC timestamps. If you need timezone support then you have to use chrono or time crate for conversion.

If chrono crate support is enabled then it will have TryInto<chrono::DateTime<Utc>> implemented. If time crate support is enabled then it will have TryInto<time::OffsetDateTime> implemented.

Implementations

impl SntpDateTime

pub fn unix_timestamp(&self) -> Result<Duration, ConversionError>

Returns with the duration since Unix epoch i.e. Unix timestamp

Then conversion can fail in cases like internal overflow or when the date is not representable with a Unix timestamp (like it is before Unix epoch).

Note that the function uses the actual system time during execution so assumes that it is monotonic. If the time has been changed between the actual synchronization and the call of this function, then it may return with undefined results.

use rsntp::SntpClient;

let client = SntpClient::new();
let result = client.synchronize("pool.ntp.org").unwrap();

let unix_timetamp_utc = result.datetime().unix_timestamp().unwrap();

Examples found in repository

examples/blocking_without_chrono.rs (line 15)

fn main() {
    let client = rsntp::SntpClient::new();
    let time_info = client.synchronize("pool.ntp.org").unwrap();

    println!(
        "Clock offset: {} ms",
        time_info.clock_offset().as_secs_f64() * 1000.0
    );
    println!(
        "Round trip delay: {} ms",
        time_info.round_trip_delay().as_secs_f64() * 1000.0
    );
    println!(
        "Server UTC UNIX timestamp: {}",
        time_info.datetime().unix_timestamp().unwrap().as_secs()
    );

    println!(
        "Reference identifier: {}",
        time_info.reference_identifier().to_string()
    );
    println!("Stratum: {}", time_info.stratum());
}

pub fn into_system_time(self) -> Result<SystemTime, ConversionError>

Convert instance to std::time::SystemTime.

Convenience wrapper for TryInto<std::time::SystemTime>::try_into to avoid type annotations.

pub fn into_chrono_datetime(self) -> Result<DateTime<Utc>, ConversionError>

Convert instance to chrono::DateTime<chrono::Utc>.

Convenience wrapper for TryInto<chrono::DateTime<chrono::Utc>>::try_into to avoid type annotations.

pub fn into_offset_date_time(self) -> Result<OffsetDateTime, ConversionError>

Convert instance to time::OffsetDateTime.

Convenience wrapper for TryInto<time::OffsetDateTime>::try_into to avoid type annotations.

Trait Implementations

impl Clone for SntpDateTime

fn clone(&self) -> SntpDateTime

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SntpDateTime

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

Formats the value using the given formatter.

impl TryInto<DateTime<Utc>> for SntpDateTime

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<DateTime<Utc>, ConversionError>

Performs the conversion.

impl TryInto<OffsetDateTime> for SntpDateTime

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<OffsetDateTime, ConversionError>

Performs the conversion.

impl TryInto<SystemTime> for SntpDateTime

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_into(self) -> Result<SystemTime, ConversionError>

Performs the conversion.

impl Copy for SntpDateTime