Enum StrategyError 

pub enum StrategyError {
    PriceError(PriceErrorKind),
    BreakEvenError(BreakEvenErrorKind),
    ProfitLossError(ProfitLossErrorKind),
    OperationError(OperationErrorKind),
    NotImplemented,
    Simulation(Box<SimulationError>),
    GreeksError(GreeksError),
    PositiveError(PositiveError),
    NumericConversion {
        value: f64,
    },
    MissingGreek {
        name: &'static str,
    },
    EmptyCollection {
        context: String,
    },
}

Represents the different types of errors that can occur in options trading strategies.

This enum acts as a comprehensive error type for the options strategy module, grouping more specific error categories for better error handling. Each variant corresponds to a different domain of potential failures within options strategy operations.

Variants

• PriceError - Errors related to pricing operations such as invalid prices or ranges
• BreakEvenError - Errors encountered when calculating strategy break-even points
• ProfitLossError - Errors related to profit/loss calculations including maximum values
• OperationError - General strategy operation errors including unsupported operations
• NotImplemented - For features or operations that are not yet implemented
• Simulation - Simulation-layer errors surfaced while evaluating a strategy

Usage

This error type is designed to be returned from functions that perform operations on options trading strategies, providing structured and detailed error information to facilitate debugging and error handling.

Variants

PriceError(PriceErrorKind)

Errors related to price calculations

BreakEvenError(BreakEvenErrorKind)

Errors related to break-even points

ProfitLossError(ProfitLossErrorKind)

Errors related to profit/loss calculations

OperationError(OperationErrorKind)

Errors related to strategy operations

NotImplemented

Indicates a feature or operation that has not been implemented yet

Simulation(Box<SimulationError>)

A simulation-layer error surfaced while evaluating a strategy.

GreeksError(GreeksError)

Greeks errors

PositiveError(PositiveError)

Positive value errors

NumericConversion

Numeric conversion failed at the f64 ↔ Decimal boundary.

Raised when a non-finite (NaN / ±Inf) f64 cannot be represented as a Decimal, or when a representation overflow occurs.

Fields

value: f64

The offending f64 value that could not be converted.

MissingGreek

A required greek value was missing from an option.

Raised when a strategy expects a greek (delta, gamma, vega, theta, rho) to be present on an option (e.g., for delta-neutral validation) but the option’s greek calculation returned None.

Fields

name: &'static str

Name of the greek ("delta", "gamma", "vega", "theta", "rho").

EmptyCollection

A required collection was empty when at least one element was expected.

Raised when a strategy operation needs to pick an element out of a collection (option chain, break-even points, profit ranges) and the collection turned out to be empty.

Fields

context: String

Description of where the empty collection was encountered.

Implementations

impl StrategyError

pub fn operation_not_supported(operation: &str, strategy_type: &str) -> Self

Creates a StrategyError for an unsupported operation on a specific strategy type.

This helper method creates a structured error describing an operation that cannot be performed on a particular strategy type, encapsulating both the attempted operation name and the strategy type that doesn’t support it.

Parameters

• operation - The name of the operation that was attempted but is not supported
• strategy_type - The type of strategy for which the operation is not supported

Returns

A StrategyError::OperationError variant with the NotSupported kind

Example

use optionstratlib::error::strategies::StrategyError;

// Creating an error when trying to calculate butterfly spread adjustment on an iron condor
let error = StrategyError::operation_not_supported("butterfly_adjustment", "IronCondor");

pub fn invalid_parameters(operation: &str, reason: &str) -> Self

Creates a StrategyError for invalid parameters provided to an operation.

This helper method builds a structured error for cases when an operation fails due to invalid or insufficient parameters, providing context about both the operation and the specific validation issue.

Parameters

• operation - The name of the operation that failed due to invalid parameters
• reason - A descriptive explanation of why the parameters are invalid

Returns

A StrategyError::OperationError variant with the InvalidParameters kind

Example

use optionstratlib::error::strategies::StrategyError;

// Creating an error when strike prices are invalid for a strategy
let error = StrategyError::invalid_parameters(
    "create_vertical_spread",
    "Short strike must be higher than long strike for call spreads"
);

pub fn numeric_conversion(value: f64) -> Self

Builds a NumericConversion error for an f64 that could not be converted to a Decimal (typically NaN / Inf or overflow).

Errors

This is an error constructor — it always returns the variant.

pub fn missing_greek(name: &'static str) -> Self

Builds a MissingGreek error for an option missing a required greek.

Errors

This is an error constructor — it always returns the variant.

pub fn empty_collection(context: impl Into<String>) -> Self

Builds an EmptyCollection error for an unexpectedly empty collection.

Errors

This is an error constructor — it always returns the variant.

Trait Implementations

impl Debug for StrategyError

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

Formats the value using the given formatter.

impl Display for StrategyError

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

Formats the value using the given formatter.

impl Error for StrategyError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

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

Provides type-based access to context intended for error reports.

impl From<GreeksError> for StrategyError

fn from(source: GreeksError) -> Self

Converts to this type from the input type.

impl From<OptionsError> for StrategyError

fn from(err: OptionsError) -> Self

Converts to this type from the input type.

impl From<PositionError> for StrategyError

fn from(err: PositionError) -> Self

Converts to this type from the input type.

impl From<PositiveError> for StrategyError

fn from(source: PositiveError) -> Self

Converts to this type from the input type.

impl From<PricingError> for StrategyError

fn from(err: PricingError) -> Self

Converts to this type from the input type.

impl From<SimulationError> for StrategyError

fn from(err: SimulationError) -> Self

Converts to this type from the input type.

impl From<StrategyError> for PositionError

fn from(error: StrategyError) -> Self

Converts to this type from the input type.

impl From<StrategyError> for ProbabilityError

fn from(error: StrategyError) -> Self

Converts to this type from the input type.

impl From<StrategyError> for SimulationError

fn from(err: StrategyError) -> Self

Converts to this type from the input type.

impl From<StrategyError> for Error

fn from(source: StrategyError) -> Self

Converts to this type from the input type.

impl From<TradeError> for StrategyError

fn from(value: TradeError) -> Self

Converts to this type from the input type.