Enum ExpirationDate 

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

Represents the expiration of an option contract or financial instrument.

This enum allows for two different ways to specify when something expires:

• As a number of days from the current date
• As a specific date and time

ExpirationDate is used throughout the options modeling system to handle time-based calculations such as time decay (theta) and option valuation.

Variants

Days(Positive)

Represents expiration as a positive number of days from the current date. This is typically used for relative time specifications. when converting between Days and DateTime variants.

DateTime(DateTime<Utc>)

Represents expiration as an absolute point in time using UTC datetime. This is used when a precise expiration moment is known.

Implementations

impl ExpirationDate

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

Calculates the time to expiration in years.

Returns a Result<Positive, ChainError>.

Arguments

• &self - The ExpirationDate instance.

Errors

Returns an error if the DateTime variant results in a negative duration indicating the expiration date is in the past.

Examples

use chrono::{Duration, Utc};
use rust_decimal_macros::dec;
use optionstratlib::{assert_pos_relative_eq, pos, ExpirationDate};

let days = pos!(365.0);
let expiration_date_days = ExpirationDate::Days(days);
let years = expiration_date_days.get_years().unwrap();
assert_pos_relative_eq!(years, pos!(1.0), pos!(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, pos!(1.0), pos!(0.001));

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

Calculates the number of days until expiration for this ExpirationDate instance.

This method converts both variants of ExpirationDate to a common representation: the number of days until expiration. This is useful for calculations that need time-to-expiry in a standardized format.

Returns

• Result<Positive, DecimalError> - A Positive value representing the number of days until expiration, or an error if the calculation fails.

Details

• For ExpirationDate::Days variant: Returns the stored days value directly.
• For ExpirationDate::DateTime variant: Calculates the difference between the stored datetime and the current time, converting it to days.

If the calculation results in zero or negative days (meaning the expiration date is in the past), the method returns Positive::ZERO to indicate immediate expiration.

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

Returns the expiration date as a DateTime<Utc>.

For the Days variant, it calculates the date by adding the specified number of days to the current date and time. For the DateTime variant, it returns the stored DateTime<Utc>.

Examples

use chrono::{Duration, Utc};
use rust_decimal_macros::dec;
use optionstratlib::{pos, ExpirationDate};

let days = pos!(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();
// Check if dates are within a small tolerance (due to potential time differences during test)
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>, DecimalError>

Calculates and returns a DateTime<Utc> based on the specified options and expiration criteria.

Parameters

• use_fixed_time:
  • If true, a fixed daily time of 18:30 UTC is used as the base time for calculations.
  • If false, the base time for calculations depends on a reference datetime if available. If no reference datetime exists, the calculation will use the current time.

Returns

• Ok(DateTime<Utc>):
  • If the expiration date can be successfully calculated based on the provided options and stored expiration criteria (Days or DateTime).
• Err(ChainError):
  • If there is an invalid time conversion or inconsistency in the configuration.

Behavior

This function handles two expiration types:

1. ExpirationDate::Days:
   • If use_fixed_time is true:
     • Takes today’s date and sets the time to 18:30 UTC as the base datetime.
     • Adds the specified number of days from the Days variant to this fixed datetime.
   • If use_fixed_time is false:
     • Uses a stored reference datetime (get_reference_datetime, if available) as the base datetime, and adds the number of days from the Days variant.
     • If no reference datetime is found, uses the current time as the base datetime.
2. ExpirationDate::DateTime:
   • Directly returns the pre-stored datetime associated with this variant.

Errors

• Returns an error if a fixed time (18:30 UTC) cannot be correctly configured.
• Returns an error if any internal inconsistency occurs (e.g., invalid conversions).

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

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

This method calls get_date() to retrieve the DateTime<Utc> and then formats it into the specified string format.

Examples

use chrono::{Duration, Utc};
use rust_decimal_macros::dec;
use optionstratlib::{pos, ExpirationDate};

let days = pos!(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

pub fn from_string(s: &str) -> Result<Self, ChainError>

Creates an ExpirationDate from a string.

This function attempts to parse the input string s into an ExpirationDate. It supports various formats, including:

1. Positive number of days: Parses the string as a Positive number, representing days from now.
2. RFC3339 DateTime: Parses the string as an RFC3339 compliant date and time string.
3. Numeric Date (YYYYMMDD): Parses an 8-digit numeric string as year, month, and day. Sets the time to 23:59:59.
4. Common Date formats: Parses various common date formats (e.g., DD-MM-YYYY, DD MMM YYYY, etc.). Sets the time to 23:59:59.

If none of the above formats can be parsed successfully, an error is returned.

Arguments

• s - The input string to parse.

Examples

use chrono::{DateTime, Utc};
use rust_decimal_macros::dec;
use tracing::info;
use optionstratlib::{pos, ExpirationDate};

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

let rfc3339_string = "2025-01-01T12:00:00Z";
let expiration_date_rfc3339 = ExpirationDate::from_string(rfc3339_string).unwrap();
let datetime = DateTime::parse_from_rfc3339(rfc3339_string).unwrap();
assert_eq!(expiration_date_rfc3339, ExpirationDate::DateTime(DateTime::from(datetime)));

let numeric_date_string = "20250101";
let expiration_date_numeric = ExpirationDate::from_string(numeric_date_string).unwrap();
if let ExpirationDate::DateTime(dt) = expiration_date_numeric {
    assert_eq!(dt.format("%Y%m%d").to_string(), numeric_date_string);
} else {
    info!("Expected ExpirationDate::DateTime");
}


let common_date_string = "01-01-2025";
let expiration_date_common = ExpirationDate::from_string(common_date_string).unwrap();
if let ExpirationDate::DateTime(dt) = expiration_date_common {
    assert_eq!(dt.format("%d-%m-%Y").to_string(), common_date_string);
} else {
    info!("Expected ExpirationDate::DateTime");
}

pub fn from_string_to_days(s: &str) -> Result<Self, ChainError>

Converts a string representation of an expiration date into a Days variant of ExpirationDate.

Arguments

• s - A string slice representing the expiration date. The string should adhere to a format that ExpirationDate::from_string can parse.

Returns

• Ok(Self) - If the string is successfully parsed and converted into days. The result is an ExpirationDate::Days variant containing the floored number of days.
• Err(ChainError) - If parsing or conversion fails, an error wrapped in a ChainError is returned.

Errors

This function may return an error in the following cases:

• The provided string s is not in a valid or expected format.
• The computed number of days could not be retrieved from the parsed expiration date.

Note

The function assumes that floor() truncates any remaining fractional days.

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 ComposeSchema for ExpirationDate

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl Debug for ExpirationDate

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

Formats the value using the given formatter.

impl Default for ExpirationDate

fn default() -> Self

Returns the “default value” for a type.

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

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExpirationDate

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

Formats the value using the given formatter.

impl Hash for ExpirationDate

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 ExpirationDate

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 ExpirationDate

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

Tests for self and other values to be equal, and is used by ==.

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 ExpirationDate

fn partial_cmp(&self, other: &Self) -> 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::Ok, S::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.

impl Copy for ExpirationDate

impl Eq for ExpirationDate