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) -> Self

where 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.

pub fn as_ref(&self) -> TimerangeBound<&T>

Return a TimerangeBound containing a reference

This can be useful to call methods like .check_valid_at without consuming the inner T.

pub fn as_deref(&self) -> TimerangeBound<&T::Target>

where T: Deref,

Return a TimerangeBound containing a reference to T’s Deref

pub fn bounds(&self) -> (Bound<SystemTime>, Bound<SystemTime>)

Return the underlying time bounds of this object.

Trait Implementations

impl<T: Clone> Clone for TimerangeBound<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for TimerangeBound<T>

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

Formats the value using the given formatter.

impl<T> RangeBounds<SystemTime> for TimerangeBound<T>

fn start_bound(&self) -> Bound<&SystemTime>

Start index bound.

fn end_bound(&self) -> Bound<&SystemTime>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

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.