Struct Time 

#[repr(C)]
pub struct Time {
    pub value: TimeValue,
    pub scale: TimeScale,
    pub flags: TimeFlags,
    pub epoch: TimeEpoch,
}

Fields

value: TimeValue

scale: TimeScale

flags: TimeFlags

epoch: TimeEpoch

Implementations

impl Time

pub fn abs(self) -> Time

Returns the absolute value of a Time.

use cidre::cm;

let t1 = cm::Time::with_secs(-5.0, 10);
let t2 = t1.abs();
assert_eq!(t2.scale, 10);
assert_eq!(t2.as_secs(), 5.0);

pub fn add(self, rhs: Time) -> Time

use cidre::cm;

let t1 = cm::Time::with_secs(100.0, 10);
let t2 = cm::Time::with_secs(200.0, 10);
let t3 = t1.add(t2);
assert!(t3.is_valid());
assert_eq!(t3.scale, 10);
assert_eq!(t3.as_secs(), 300.0);

pub fn convert_scale( self, new_time_scale: TimeScale, rounding_method: TimeRoundingMethod, ) -> Time

use cidre::cm;

let time = cm::Time::default().convert_scale(100, cm::TimeRoundingMethod::default());
assert!(time.is_valid());
assert_eq!(time.scale, 100);

pub fn desc_in(self, allocator: Option<&Allocator>) -> Option<R<String>>

pub fn desc(self) -> Option<R<String>>

pub fn as_secs(self) -> f64

Converts a Time to seconds.

pub fn indefinit() -> Time

pub fn invalid() -> Time

pub const fn is_invalid(&self) -> bool

use cidre::cm;

let time = cm::Time::invalid();
assert!(!time.is_valid());
assert!(time.is_invalid());

pub const fn is_neg_infinity(&self) -> bool

use cidre::cm;

assert!(cm::Time::neg_infinity().is_neg_infinity())

pub const fn is_pos_infinity(&self) -> bool

use cidre::cm;

assert!(cm::Time::infinity().is_pos_infinity());

pub const fn is_indefinite(&self) -> bool

pub const fn is_numeric(&self) -> bool

pub const fn has_been_rounded(&self) -> bool

Returns true if the cm::Time has been rounded, false if it is completely accurate.

pub const fn is_valid(&self) -> bool

Returns Time from a f64 number of seconds, and a preferred timescale.

use cidre::cm;

let time = cm::Time::with_secs(100.0, 40_000);
assert!(time.is_valid());

pub const fn is_ok(&self) -> bool

pub fn mul_i32(self, multiplier: i32) -> Time

use cidre::cm;

let t1 = cm::Time::with_secs(5.0, 10);
let t2 = t1.mul_i32(2);
assert!(t2.is_valid());
assert_eq!(t2.scale, 10);
assert_eq!(t2.as_secs(), 10.0);

pub fn mul_f64(self, multiplier: f64) -> Time

pub fn new(value: TimeValue, timescale: i32) -> Time

Returns valid Time with value and timescale. Epoch is implied to be 0.

use cidre::cm;

let time = cm::Time::new(100, 10);
assert!(time.is_valid());
assert_eq!(time.epoch, 0);

pub fn infinity() -> Time

pub fn neg_infinity() -> Time

pub fn show(self)

pub fn sub(self, rhs: Time) -> Time

use cidre::cm;

let t1 = cm::Time::with_secs(100.0, 10);
let t2 = cm::Time::with_secs(100.0, 10);
let t3 = t1.sub(t2);
assert!(t3.is_valid());
assert_eq!(t3.scale, 10);
assert_eq!(t3.as_secs(), 0.0);

pub fn with_epoch(value: TimeValue, timescale: i32, epoch: TimeEpoch) -> Time

use cidre::cm;

let time = cm::Time::with_epoch(100, 10, 5);
assert!(time.is_valid());
assert_eq!(time.epoch, 5);

pub fn with_secs(seconds: f64, preferred_timescale: TimeScale) -> Time

Returns Time from a f64 number of seconds, and a preferred timescale.

use cidre::cm;

let time = cm::Time::with_secs(100.0, 10);
assert!(time.is_valid());
assert_eq!(time.scale, 10);
assert_eq!(time.as_secs(), 100.0);

pub const fn zero() -> Time

pub fn max(l: Time, r: Time) -> Time

pub fn min(l: Time, r: Time) -> Time

Trait Implementations

impl Clone for Time

fn clone(&self) -> Time

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Time

impl Debug for Time

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

Formats the value using the given formatter.

impl Default for Time

fn default() -> Self

use cidre::cm;

let t1 = cm::Time::default();
assert_eq!(t1, cm::Time::zero());

impl Eq for Time

impl Hash for Time

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 Ord for Time

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Time

fn eq(&self, other: &Self) -> bool

use cidre::cm;

let t1 = cm::Time::with_secs(5.0, 10);
let t2 = t1.mul_i32(2);
let t3 = cm::Time::with_secs(5.0, 100);
assert!(t1 != t2);
assert!(t1 == t1);
assert!(t1 == t3);

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 PartialOrd for Time

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

use cidre::cm;

let t1 = cm::Time::with_secs(5.0, 10);
let t2 = cm::Time::with_secs(5.5, 10);
assert!(t1 < t2);
assert!(cm::Time::neg_infinity() < cm::Time::zero());
assert!(cm::Time::neg_infinity() < cm::Time::infinity());
assert!(cm::Time::zero() < cm::Time::infinity());

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.