Struct tor_checkable::timed::TimerangeBound

pub struct TimerangeBound<T> { /* private fields */ }

A TimeBound object that is valid for a specified range of time.

The range is given as an argument, as in t1..t2.

use std::time::{SystemTime, Duration};
use tor_checkable::{Timebound, TimeValidityError, timed::TimerangeBound};

let now = SystemTime::now();
let one_hour = Duration::new(3600, 0);

// This seven is only valid for another hour!
let seven = TimerangeBound::new(7_u32, ..now+one_hour);

assert_eq!(seven.check_valid_at(&now).unwrap(), 7);

// That consumed the previous seven. Try another one.
let seven = TimerangeBound::new(7_u32, ..now+one_hour);
assert_eq!(seven.check_valid_at(&(now+2*one_hour)),
           Err(TimeValidityError::Expired(one_hour)));

Implementations

impl<T> TimerangeBound<T>

pub fn new<U>(obj: T, range: U) -> Selfwhere U: RangeBounds<SystemTime>,

Construct a new TimerangeBound object from a given object and range.

Note that we do not distinguish between inclusive and exclusive bounds: x..y and x..=y are treated the same here.

pub fn extend_tolerance(self, d: Duration) -> Self

Adjust this time-range bound to tolerate an expiration time farther in the future.

pub fn extend_pre_tolerance(self, d: Duration) -> Self

Adjust this time-range bound to tolerate an initial validity time farther in the past.

pub fn dangerously_map<F, U>(self, f: F) -> TimerangeBound<U>where F: FnOnce(T) -> U,

Consume this TimerangeBound, and return a new one with the same bounds, applying f to its protected value.

The caller must ensure that f does not make any assumptions about the timeliness of the protected value, or leak any of its contents in an inappropriate way.

pub fn dangerously_into_parts( self ) -> (T, (Bound<SystemTime>, Bound<SystemTime>))

Consume this TimeRangeBound, and return its underlying time bounds and object.

The caller takes responsibility for making sure that the bounds are actually checked.

pub fn dangerously_peek(&self) -> &T

Return a reference to the inner object of this TimeRangeBound, without checking the time interval.

The caller takes responsibility for making sure that nothing is actually done with the inner object that would rely on the bounds being correct, until the bounds are (eventually) checked.

Trait Implementations

impl<T> Timebound<T> for TimerangeBound<T>

type Error = TimeValidityError

An error type that’s returned when the object is not timely.

fn is_valid_at(&self, t: &SystemTime) -> Result<(), Self::Error>

Check whether this object is valid at a given time.

fn dangerously_assume_timely(self) -> T

Return the underlying object without checking whether it’s valid.

fn check_valid_at(self, t: &SystemTime) -> Result<T, Self::Error>

Unwrap this Timebound object if it is valid at a given time.

fn check_valid_now(self) -> Result<T, Self::Error>

Unwrap this Timebound object if it is valid now.

fn check_valid_at_opt(self, t: Option<SystemTime>) -> Result<T, Self::Error>

Unwrap this object if it is valid at the provided time t. If no time is provided, check the object at the current time.