Enum RuleConfigDef 

pub enum RuleConfigDef {
    FixedStoploss {
        price: f64,
    },
    TrailingStop {
        distance: f64,
    },
    TakeProfit {
        price: f64,
        close_ratio: f64,
    },
    BreakevenWhen {
        trigger_price: f64,
    },
    BreakevenWhenOffset {
        trigger_price_offset: f64,
    },
    BreakevenAfterTargets {
        after_n: u32,
    },
    TimeExit {
        max_seconds: u64,
    },
}

Profile-specific rule definition with #[serde(tag = "type")] for TOML.

Converts to the core RuleConfig enum. Includes an offset-based BreakevenWhenOffset variant that computes the absolute trigger price from the signal’s entry price at apply time.

Variants

FixedStoploss

Fixed stoploss at an absolute price.

Fields

price: f64

TrailingStop

Trailing stop with a fixed distance.

Fields

distance: f64

TakeProfit

Take profit at an absolute price with a close ratio.

Fields

price: f64

close_ratio: f64

BreakevenWhen

Breakeven trigger at an absolute price.

Fields

trigger_price: f64

BreakevenWhenOffset

Breakeven trigger as an offset from the entry price (profile-specific).

Fields

trigger_price_offset: f64

BreakevenAfterTargets

Breakeven after N targets have been hit.

Fields

after_n: u32

TimeExit

Time-based exit after N seconds.

Fields

max_seconds: u64

Implementations

impl RuleConfigDef

pub fn resolve( &self, entry_price: Option<f64>, side: Side, ) -> Option<RuleConfig>

Resolve this definition into a core RuleConfig.

For offset-based variants, entry_price and side are needed to compute the absolute trigger price. Returns None when the offset variant is used but no entry price is available.

Trait Implementations

impl Clone for RuleConfigDef

fn clone(&self) -> RuleConfigDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuleConfigDef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RuleConfigDef

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for RuleConfigDef

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.