Enum ExpirationDate 

pub enum ExpirationDate {
    Days(Positive),
    DateTime(DateTime<Utc>),
}

Represents the expiration of a financial instrument.

Variants

Days(Positive)

Relative expiration in positive fractional days.

DateTime(DateTime<Utc>)

Absolute expiration point in UTC.

Implementations

impl ExpirationDate

pub fn get_years_with_convention<C>( &self, convention: C, ) -> Result<Positive, ExpirationDateError>

where C: DayCount,

Calculates years using a specific day count convention.

Errors

Returns ExpirationDateError if calculation fails.

pub fn get_years(&self) -> Result<Positive, ExpirationDateError>

Calculates years until expiration using standard Actual/365 Fixed.

Errors

Returns ExpirationDateError if calculation fails.

Examples

use chrono::{Duration, Utc};
use positive::{assert_pos_relative_eq, pos_or_panic, Positive};
use expiration_date::ExpirationDate;

let days = pos_or_panic!(365.0);
let expiration_date_days = ExpirationDate::Days(days);
let years = expiration_date_days.get_years().unwrap();
assert_pos_relative_eq!(years, Positive::ONE, pos_or_panic!(0.001));

let datetime = Utc::now() + Duration::days(365);
let expiration_date_datetime = ExpirationDate::DateTime(datetime);
let years = expiration_date_datetime.get_years().unwrap();
assert_pos_relative_eq!(years, Positive::ONE, pos_or_panic!(0.01));

pub fn get_days(&self) -> Result<Positive, ExpirationDateError>

Returns the number of fractional days until expiration.

Errors

Returns ExpirationDateError if conversion to Positive fails.

pub fn get_date(&self) -> Result<DateTime<Utc>, ExpirationDateError>

Resolves expiration to an absolute DateTime<Utc>.

Errors

Returns ExpirationDateError if construction fails.

Examples

use chrono::{Duration, Utc};
use positive::pos_or_panic;
use expiration_date::ExpirationDate;

// Clear any stored reference datetime from previous tests so the
// relative calculation uses `Utc::now()` as its base.
ExpirationDate::set_reference_datetime(None);

let days = pos_or_panic!(30.0);
let expiration_date_days = ExpirationDate::Days(days);
let future_date = Utc::now() + Duration::days(30);
let calculated_date = expiration_date_days.get_date().unwrap();
assert_eq!(calculated_date.date_naive(), future_date.date_naive());

let datetime = Utc::now() + Duration::days(365);
let expiration_date_datetime = ExpirationDate::DateTime(datetime);
let stored_date = expiration_date_datetime.get_date().unwrap();
assert_eq!(stored_date, datetime);

pub fn get_date_with_options( &self, use_fixed_time: bool, ) -> Result<DateTime<Utc>, ExpirationDateError>

Resolves datetime with advanced base-time options.

Errors

Returns ExpirationDateError if the construction fails.

pub fn get_date_string(&self) -> Result<String, ExpirationDateError>

Returns the expiration date as a formatted YYYY-MM-DD string.

Errors

Returns error if the date cannot be resolved.

Examples

use positive::pos_or_panic;
use expiration_date::ExpirationDate;

let days = pos_or_panic!(30.0);
let expiration_date = ExpirationDate::Days(days);
let date_string = expiration_date.get_date_string().unwrap();
assert!(date_string.len() == 10); // YYYY-MM-DD format

impl ExpirationDate

pub fn from_string(s: &str) -> Result<ExpirationDate, ExpirationDateError>

Parse expiration from string using multiple formats.

Supports the following input shapes:

1. Positive number of days: e.g., "30.0"
2. ISO date: e.g., "2025-01-01"
3. Date with time and timezone: e.g., "2025-01-01 12:00:00 UTC"
4. RFC3339-like with time: e.g., "2025-05-23T15:29" or "2025-05-23T15:29:00Z"
5. Numeric date (YYYYMMDD): e.g., "20250101"
6. Common date formats: e.g., "01-01-2025", "30 jan 2025", "30-jan-2025", "30 january 2025", "30-january-2025"

Month names are matched case-insensitively.

Errors

Returns ExpirationDateError::ParseError if format matches no known pattern, or ExpirationDateError::InvalidDateTime if the derived time components are out of range.

Examples

use expiration_date::ExpirationDate;
use positive::pos_or_panic;

let exp_days = ExpirationDate::from_string("365").unwrap();
assert_eq!(exp_days, ExpirationDate::Days(pos_or_panic!(365.0)));

let exp_date = ExpirationDate::from_string("2025-12-31").unwrap();

pub fn from_string_to_days( s: &str, ) -> Result<ExpirationDate, ExpirationDateError>

Parses string and converts result to Days variant.

Errors

Returns error if parsing or conversion fails.

impl ExpirationDate

pub fn set_reference_datetime(dt: Option<DateTime<Utc>>)

Sets the reference datetime for Days variant calculations.

pub fn get_reference_datetime() -> Option<DateTime<Utc>>

Gets the current reference datetime.

Trait Implementations

impl Clone for ExpirationDate

fn clone(&self) -> ExpirationDate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ExpirationDate

impl Debug for ExpirationDate

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

Formats the value using the given formatter.

impl Default for ExpirationDate

fn default() -> ExpirationDate

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExpirationDate

fn deserialize<D>( deserializer: D, ) -> Result<ExpirationDate, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExpirationDate

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

Formats the value using the given formatter.

impl Eq for ExpirationDate

impl Hash for ExpirationDate

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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 ExpirationDate

fn cmp(&self, other: &ExpirationDate) -> 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.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for ExpirationDate

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ExpirationDate

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

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

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.

impl Serialize for ExpirationDate

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for ExpirationDate

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.