Struct Gps 

pub struct Gps;

GPS — American Global Positioning System

• Epoch: 1980-01-06 UTC
• GPS = TAI − 19 seconds
• No leap seconds (fixed offset)
• Format: "GPS 2345:432000.000"

Trait Implementations

impl Clone for Gps

fn clone(&self) -> Gps

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Gps

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

Formats the value using the given formatter.

impl Hash for Gps

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 IntoScale<Gps> for Time<Beidou>

fn into_scale(self) -> Result<Time<Gps>, GnssTimeError>

BeiDou -> GPS: GPS = BDT + 14s.

use gnss_time::{Beidou, Gps, IntoScale, Time};

let bdt = Time::<Beidou>::from_seconds(86);
let gps: Time<Gps> = bdt.into_scale().unwrap();

assert_eq!(gps.as_seconds(), 100); // 86 - 19 + 33 = 100

impl IntoScale<Gps> for Time<Galileo>

fn into_scale(self) -> Result<Time<Gps>, GnssTimeError>

Converts the value into the target time scale.

impl IntoScale<Gps> for Time<Tai>

fn into_scale(self) -> Result<Time<Gps>, GnssTimeError>

TAI -> GPS: subtract 19 seconds.

use gnss_time::{Gps, IntoScale, Tai, Time};

let tai = Time::<Tai>::from_seconds(119);
let gps: Time<Gps> = tai.into_scale().unwrap();

assert_eq!(gps.as_seconds(), 100);

impl IntoScaleWith<Gps> for Time<Glonass>

fn into_scale_with<P: LeapSecondsProvider>( self, ls: P, ) -> Result<Time<Gps>, GnssTimeError>

GLONASS -> GPS via UTC.

fn into_scale_with_checked<P: LeapSecondsProvider>( self, ls: P, ) -> Result<ConvertResult<Time<Gps>>, GnssTimeError>

Converts and reports whether the result is ambiguous due to a leap-second insertion.

impl IntoScaleWith<Gps> for Time<Utc>

fn into_scale_with<P: LeapSecondsProvider>( self, ls: P, ) -> Result<Time<Gps>, GnssTimeError>

UTC -> GPS with leap-second context.

use gnss_time::{DurationParts, Gps, IntoScale, IntoScaleWith, LeapSeconds, Time, Utc};

let ls = LeapSeconds::builtin();
let gps_orig = Time::<Gps>::from_week_tow(
    2086,
    DurationParts {
        seconds: 0,
        nanos: 0,
    },
)
.unwrap();
let utc: Time<Utc> = gps_orig.into_scale_with(ls).unwrap();
let gps_back: Time<Gps> = utc.into_scale_with(ls).unwrap();

assert_eq!(gps_orig, gps_back);

fn into_scale_with_checked<P: LeapSecondsProvider>( self, ls: P, ) -> Result<ConvertResult<Time<Gps>>, GnssTimeError>

Converts and reports whether the result is ambiguous due to a leap-second insertion.

impl PartialEq for Gps

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

const NAME: &'static str = "GPS"

Short identifier used in formatting.

const OFFSET_TO_TAI: OffsetToTai

Offset relative to TAI:

const EPOCH_CIVIL: CivilDate

Civil epoch of the scale (where time == 0).

const DISPLAY_STYLE: DisplayStyle = DisplayStyle::WeekTow

Formatting style for display output.

impl Copy for Gps

impl Eq for Gps

impl StructuralPartialEq for Gps