Enum PositionError 

pub enum PositionError {
    StrategyError(StrategyErrorKind),
    ValidationError(PositionValidationErrorKind),
    LimitError(PositionLimitErrorKind),
    UpdateError(PositionUpdateErrorKind),
    DecimalError(DecimalError),
    PositiveError(PositiveError),
    Options(OptionsError),
}

Represents errors that can occur when managing positions in strategies

This enum provides a top-level categorization of position-related errors, grouping them by their source or nature. It helps with routing errors to appropriate handlers and providing context-aware error messages.

Variants

• StrategyError - Errors related to strategy operations such as configuration issues or capacity limitations.

• ValidationError - Errors related to position validation including issues with size, price, or compatibility with strategy requirements.

• LimitError - Errors related to position limits such as maximum number of positions or maximum exposure thresholds.

Usage

This error type is typically used in trading systems where positions need to be validated, managed, and executed within the context of trading strategies.

Variants

StrategyError(StrategyErrorKind)

Errors related to strategy operations

ValidationError(PositionValidationErrorKind)

Errors related to position validation

LimitError(PositionLimitErrorKind)

Errors related to position limits

UpdateError(PositionUpdateErrorKind)

Error during position update

This variant is triggered when attempts to update option position parameters or data fail. Errors related to position update

DecimalError(DecimalError)

Decimal arithmetic failures propagated from monetary-flow computations (overflow, division by zero, conversion).

Produced when a checked Decimal helper in model::decimal surfaces a crate::error::DecimalError from inside a Position method (for example pnl_at_expiration or unrealized_pnl). Propagated transparently via the #[from] cascade so callers keep matching PositionError.

PositiveError(PositiveError)

Positive arithmetic failures propagated from cost and fee computations (overflow, division by zero, broken positivity invariant).

Produced when a checked Positive helper surfaces a positive::PositiveError from inside a Position method (for example total_cost or fees, where the premium and the fees are accumulated and then scaled by the contract quantity). Propagated transparently via the #[from] cascade so callers keep matching PositionError.

Options(OptionsError)

Contract-level failures propagated from the option the position holds.

Produced when Options::intrinsic_value surfaces an crate::error::OptionsError inside a Position or Leg P&L method. Both types are core-owned, so the position layer reports a contract failure with its own error instead of borrowing the pricing layer’s (roadmap M1-10).

Implementations

impl PositionError

Factory methods for creating position-related errors

This implementation provides a set of convenience factory methods for creating different types of position errors. These methods create properly structured error instances with clear, descriptive information about what went wrong.

Methods

These factory methods simplify error creation throughout the codebase and ensure that errors have consistent formatting and information.

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

Creates an error for operations not supported by a specific strategy type

Parameters

• strategy_type - The name or identifier of the strategy that doesn’t support the operation
• operation - The name of the unsupported operation that was attempted

Returns

A PositionError::StrategyError variant with UnsupportedOperation details

pub fn strategy_full(strategy_type: &str, max_positions: usize) -> Self

Creates an error when a strategy has reached its maximum position capacity

Parameters

• strategy_type - The name or identifier of the strategy that is at capacity
• max_positions - The maximum number of positions the strategy can hold

Returns

A PositionError::StrategyError variant with StrategyFull details

pub fn invalid_position_size(size: f64, reason: &str) -> Self

Creates an error for invalid position size values

Parameters

• size - The invalid position size value
• reason - A description of why the size is invalid

Returns

A PositionError::ValidationError variant with InvalidSize details

pub fn invalid_position_type(position_side: Side, reason: String) -> Self

Creates an error for incompatible position side/direction

Parameters

• position_side - The position side (Long or Short) that is incompatible
• reason - A description of why the position side is incompatible

Returns

A PositionError::ValidationError variant with IncompatibleSide details

pub fn invalid_position_style(style: OptionStyle, reason: String) -> Self

Creates an error for incompatible option style

Parameters

• style - The option style (Call or Put) that is incompatible
• reason - A description of why the option style is incompatible

Returns

A PositionError::ValidationError variant with IncompatibleStyle details

pub fn invalid_position(reason: &str) -> Self

Creates a generic invalid position error

Parameters

• reason - A description of why the position is invalid

Returns

A PositionError::ValidationError variant with InvalidPosition details

pub fn invalid_position_update(field: String, reason: String) -> Self

Creates an error for invalid position update

Parameters

• field - The option position field that failed to update
• reason - A description of why the option position field failed to update

Returns

A PositionError::UpdateError variant with PositionFieldUpdateFailure details

Trait Implementations

impl Debug for PositionError

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

Formats the value using the given formatter.

impl Display for PositionError

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

Formats the value using the given formatter.

impl Error for PositionError

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<DecimalError> for PositionError

fn from(source: DecimalError) -> Self

Converts to this type from the input type.

impl From<OptionsError> for PositionError

fn from(source: OptionsError) -> Self

Converts to this type from the input type.

impl From<PositiveError> for PositionError

fn from(source: PositiveError) -> Self

Converts to this type from the input type.