Enum Stamp 

pub enum Stamp<T = Timestamp>
where
    T: TimePoint,
{
    Static,
    At(T),
}

When a transform is valid: at one instant, or for all time.

Stamp is what Transform::timestamp returns and what its constructors take: a dynamic sample carries Stamp::At(t), a fixed relationship such as a sensor mount carries Stamp::Static. Staticness is a separate variant rather than a reserved timestamp value, so every instant the clock can produce — including t = 0 on boot-relative clocks — is ordinary dynamic data.

Examples

use transforms::time::{Stamp, Timestamp};

let dynamic: Stamp = Stamp::At(Timestamp::zero());
let fixed: Stamp = Stamp::Static;

assert!(!dynamic.is_static());
assert!(fixed.is_static());
assert_eq!(dynamic.at(), Some(Timestamp::zero()));
assert_eq!(fixed.at(), None);

Stamp is deliberately not ordered. Static denotes all time rather than an instant, so it has no position on a time axis; a derived ordering would place it below every real instant and make the natural freshest-sample idiom (max_by_key(|tf| tf.timestamp)) rank an eternal transform as older than the epoch. Order the instants themselves — via Stamp::at — and decide what static means for the comparison at hand.

With the optional serde feature, Stamp serializes as an explicitly tagged enum: Stamp::At(t) as {"At": t} and Stamp::Static as "Static" in JSON, and as a variant index followed by the payload in non-self-describing formats. No timestamp value is reserved, and neither an absent nor a null timestamp field decodes — a message that lost its stamp is an error, never an eternal static transform.

Variants

Static

Valid for all time: a fixed frame relationship that never expires.

At(T)

Valid at one instant.

Implementations

impl<T> Stamp<T>

where T: TimePoint,

pub const fn is_static(&self) -> bool

Returns true for Stamp::Static.

pub const fn at(self) -> Option<T>

Returns the instant for Stamp::At, or None for Stamp::Static.

Trait Implementations

impl<T> Clone for Stamp<T>

where T: TimePoint + Clone,

fn clone(&self) -> Stamp<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Stamp<T>

where T: TimePoint + Copy,

impl<T> Debug for Stamp<T>

where T: TimePoint + Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Stamp<T>

where T: TimePoint + Deserialize<'de>,

Available on crate feature serde only.

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Eq for Stamp<T>

where T: TimePoint + Eq,

impl<T> PartialEq for Stamp<T>

where T: TimePoint + PartialEq,

fn eq(&self, other: &Stamp<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T> Serialize for Stamp<T>

where T: TimePoint + Serialize,

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Stamp<T>

where T: TimePoint + PartialEq,