Struct sequoia_openpgp::types::Duration

pub struct Duration(/* private fields */);

A duration representable by OpenPGP.

Examples

use sequoia_openpgp as openpgp;
use openpgp::cert::prelude::*;
use openpgp::policy::StandardPolicy;
use openpgp::packet::signature::subpacket::{SubpacketTag, SubpacketValue};
use openpgp::types::{Timestamp, Duration};

let p = &StandardPolicy::new();

let now = Timestamp::now();
let validity_period = Duration::days(365)?;

let (cert,_) = CertBuilder::new()
    .set_creation_time(now)
    .set_validity_period(validity_period)
    .generate()?;

let vc = cert.with_policy(p, now)?;
assert!(vc.alive().is_ok());

Implementations

impl Duration

pub const fn seconds(n: u32) -> Duration

Returns a Duration with the given number of seconds.

pub fn minutes(n: u32) -> Result<Duration>

Returns a Duration with the given number of minutes, if representable.

pub fn hours(n: u32) -> Result<Duration>

Returns a Duration with the given number of hours, if representable.

pub fn days(n: u32) -> Result<Duration>

Returns a Duration with the given number of days, if representable.

pub fn weeks(n: u32) -> Result<Duration>

Returns a Duration with the given number of weeks, if representable.

pub fn years(n: u32) -> Result<Duration>

Returns a Duration with the given number of years, if representable.

This function assumes that there are 365.2425 days in a year, the average number of days in a year in the Gregorian calendar.

pub fn as_secs(self) -> u64

Returns the duration as seconds.

pub fn round_up<P, C>(&self, precision: P, ceil: C) -> Result<Duration>

where P: Into<Option<u8>>, C: Into<Option<SystemDuration>>,

Rounds up to the given level of precision.

If Timestamp::round_down is used to round the creation timestamp of a key or signature down, then this function may be used to round the corresponding expiration time up. This ensures validity during the originally intended lifetime, while avoiding the metadata leak associated with preserving the originally intended expiration time.

The given level p determines the resulting resolution of 2^p seconds. The default is 21, which results in a resolution of 24 days, or roughly a month. p must be lower than 32.

The upper limit ceil represents the maximum time to round up to.

Trait Implementations

impl Clone for Duration

fn clone(&self) -> Duration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Duration

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

Formats the value using the given formatter.

impl From<Duration> for Duration

fn from(d: Duration) -> Self

Converts to this type from the input type.

impl From<Duration> for Option<Duration>

fn from(d: Duration) -> Self

Converts to this type from the input type.

impl From<Duration> for u32

fn from(d: Duration) -> Self

Converts to this type from the input type.

impl From<u32> for Duration

fn from(d: u32) -> Self

Converts to this type from the input type.

impl Hash for Duration

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 Duration

fn cmp(&self, other: &Duration) -> 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 + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Duration

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Duration

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

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl TryFrom<Duration> for Duration

type Error = Error

The type returned in the event of a conversion error.

fn try_from(d: SystemDuration) -> Result<Self>

Performs the conversion.

impl Copy for Duration

impl Eq for Duration

impl StructuralPartialEq for Duration